1# This file was auto generated by Styx.
   2# Do not edit this file directly.
   3
   4import typing
   5import pathlib
   6from styxdefs import *
   7import dataclasses
   8
   9C3D_METADATA = Metadata(
  10    id="58e07723e7477ee290e9447fb17235326c45f8c8.boutiques",
  11    name="c3d",
  12    package="c3d",
  13    container_image_tag="pyushkevich/itksnap:v3.8.2",
  14)
  15
  16
  17@dataclasses.dataclass
  18class C3dAccum:
  19    """
  20    -accum, -endaccum: Accumulate operations over all images
  21    
  22    Syntax: `-accum command-list -endaccum`
  23    
  24    Apply a binary operation (such as addition or multiplication) to all the
  25    images on the stack in a cumulative fashion. The command(s) will be applied
  26    to the last and second-to-last images on the stack, then to the result of
  27    this operation and the third-to-last image on the stack and so on. Below is
  28    the example of using the command to add multiple images.
  29    
  30    c3d image*.nii -accum -add -endaccum -o sum.nii.
  31    """
  32    accum: str
  33    """-accum, -endaccum: Accumulate operations over all images
  34    
  35    Syntax: `-accum command-list -endaccum`
  36    
  37    Apply a binary operation (such as addition or multiplication) to all the
  38    images on the stack in a cumulative fashion. The command(s) will be applied
  39    to the last and second-to-last images on the stack, then to the result of
  40    this operation and the third-to-last image on the stack and so on. Below is
  41    the example of using the command to add multiple images.
  42    
  43    c3d image*.nii -accum -add -endaccum -o sum.nii"""
  44    
  45    def run(
  46        self,
  47        execution: Execution,
  48    ) -> list[str]:
  49        """
  50        Build command line arguments. This method is called by the main command.
  51        
  52        Args:
  53            execution: The execution object.
  54        Returns:
  55            Command line arguments
  56        """
  57        cargs = []
  58        cargs.extend([
  59            "-accum",
  60            self.accum
  61        ])
  62        return cargs
  63
  64
  65@dataclasses.dataclass
  66class C3dAcos:
  67    """
  68    No description found.
  69    """
  70    acos: str
  71    """No description found."""
  72    
  73    def run(
  74        self,
  75        execution: Execution,
  76    ) -> list[str]:
  77        """
  78        Build command line arguments. This method is called by the main command.
  79        
  80        Args:
  81            execution: The execution object.
  82        Returns:
  83            Command line arguments
  84        """
  85        cargs = []
  86        cargs.extend([
  87            "-acos",
  88            self.acos
  89        ])
  90        return cargs
  91
  92
  93@dataclasses.dataclass
  94class C3dAdd:
  95    """
  96    -add: Voxelwise image addition
  97    
  98    Syntax: `-add`
  99    
 100    Adds the last two images on the stack, and places the sum at the end of the
 101    stack.
 102    
 103    # Add two images: x = a + b
 104    c3d a.img b.img -add -o x.img
 105    
 106    # Add three images, x = (a + b) + c in the first example, x = a + (b + c) in
 107    the second
 108    c3d a.img b.img -add c.img -add -o x.img
 109    c3d a.img b.img c.img -add -add -o x.img
 110    
 111    # Subtract two images, using -scale command: x = a - b
 112    c3d a.img b.img -scale -1 -add -o x.img.
 113    """
 114    add: str
 115    """-add: Voxelwise image addition
 116    
 117    Syntax: `-add`
 118    
 119    Adds the last two images on the stack, and places the sum at the end of the
 120    stack.
 121    
 122    # Add two images: x = a + b
 123    c3d a.img b.img -add -o x.img
 124    
 125    # Add three images, x = (a + b) + c in the first example, x = a + (b + c) in
 126    the second
 127    c3d a.img b.img -add c.img -add -o x.img
 128    c3d a.img b.img c.img -add -add -o x.img
 129    
 130    # Subtract two images, using -scale command: x = a - b
 131    c3d a.img b.img -scale -1 -add -o x.img"""
 132    
 133    def run(
 134        self,
 135        execution: Execution,
 136    ) -> list[str]:
 137        """
 138        Build command line arguments. This method is called by the main command.
 139        
 140        Args:
 141            execution: The execution object.
 142        Returns:
 143            Command line arguments
 144        """
 145        cargs = []
 146        cargs.extend([
 147            "-add",
 148            self.add
 149        ])
 150        return cargs
 151
 152
 153@dataclasses.dataclass
 154class C3dAlignLandmarks:
 155    """
 156    -alm, -align-landmarks: Align images based on landmark matching
 157    
 158    Syntax: `-alm dof outfile`
 159    
 160    Performs rigid or affine alignment between to sets of landmark images. A
 161    landmark image is an image where for every intensity value, the centroid of
 162    all voxels with that intensity represents a landmark. Landmarks can be
 163    created using the paintbrush tool in ITK-SNAP (they can be spheres, cubes,
 164    etc). The first image on the stack is the target/fixed/reference image, and
 165    the second is the moving image. The parameters are the degrees of freedom,
 166    which is a number (6 for rigid, 7 for rigid+scale, 12 for affine) and the
 167    output matrix file. In this example, we have images **fixed.nii* and
 168    **moving.nii** with corresponding landmark images. We use landmarks to align
 169    the moving image to the fixed:
 170    
 171    c3d fixed_landmarks.nii moving_landmarks.nii -alm 6 rigid.mat
 172    c3d fixed.nii moving.nii -reslice-matrix rigid.mat -o
 173    moving_resliced_to_fixed.nii.
 174    """
 175    align_landmarks: str
 176    """-alm, -align-landmarks: Align images based on landmark matching
 177    
 178    Syntax: `-alm dof outfile`
 179    
 180    Performs rigid or affine alignment between to sets of landmark images. A
 181    landmark image is an image where for every intensity value, the centroid of
 182    all voxels with that intensity represents a landmark. Landmarks can be
 183    created using the paintbrush tool in ITK-SNAP (they can be spheres, cubes,
 184    etc). The first image on the stack is the target/fixed/reference image, and
 185    the second is the moving image. The parameters are the degrees of freedom,
 186    which is a number (6 for rigid, 7 for rigid+scale, 12 for affine) and the
 187    output matrix file. In this example, we have images **fixed.nii* and
 188    **moving.nii** with corresponding landmark images. We use landmarks to align
 189    the moving image to the fixed:
 190    
 191    c3d fixed_landmarks.nii moving_landmarks.nii -alm 6 rigid.mat
 192    c3d fixed.nii moving.nii -reslice-matrix rigid.mat -o
 193    moving_resliced_to_fixed.nii"""
 194    
 195    def run(
 196        self,
 197        execution: Execution,
 198    ) -> list[str]:
 199        """
 200        Build command line arguments. This method is called by the main command.
 201        
 202        Args:
 203            execution: The execution object.
 204        Returns:
 205            Command line arguments
 206        """
 207        cargs = []
 208        cargs.extend([
 209            "-align-landmarks",
 210            self.align_landmarks
 211        ])
 212        return cargs
 213
 214
 215@dataclasses.dataclass
 216class C3dAnisotropicDiffusion:
 217    """
 218    -add: Voxelwise image addition
 219    
 220    Syntax: `-add`
 221    
 222    Adds the last two images on the stack, and places the sum at the end of the
 223    stack.
 224    
 225    # Add two images: x = a + b
 226    c3d a.img b.img -add -o x.img
 227    
 228    # Add three images, x = (a + b) + c in the first example, x = a + (b + c) in
 229    the second
 230    c3d a.img b.img -add c.img -add -o x.img
 231    c3d a.img b.img c.img -add -add -o x.img
 232    
 233    # Subtract two images, using -scale command: x = a - b
 234    c3d a.img b.img -scale -1 -add -o x.img.
 235    """
 236    anisotropic_diffusion: str
 237    """-add: Voxelwise image addition
 238    
 239    Syntax: `-add`
 240    
 241    Adds the last two images on the stack, and places the sum at the end of the
 242    stack.
 243    
 244    # Add two images: x = a + b
 245    c3d a.img b.img -add -o x.img
 246    
 247    # Add three images, x = (a + b) + c in the first example, x = a + (b + c) in
 248    the second
 249    c3d a.img b.img -add c.img -add -o x.img
 250    c3d a.img b.img c.img -add -add -o x.img
 251    
 252    # Subtract two images, using -scale command: x = a - b
 253    c3d a.img b.img -scale -1 -add -o x.img"""
 254    
 255    def run(
 256        self,
 257        execution: Execution,
 258    ) -> list[str]:
 259        """
 260        Build command line arguments. This method is called by the main command.
 261        
 262        Args:
 263            execution: The execution object.
 264        Returns:
 265            Command line arguments
 266        """
 267        cargs = []
 268        cargs.extend([
 269            "-anisotropic-diffusion",
 270            self.anisotropic_diffusion
 271        ])
 272        return cargs
 273
 274
 275@dataclasses.dataclass
 276class C3dAntialias:
 277    """
 278    No description found.
 279    """
 280    antialias: str
 281    """No description found."""
 282    
 283    def run(
 284        self,
 285        execution: Execution,
 286    ) -> list[str]:
 287        """
 288        Build command line arguments. This method is called by the main command.
 289        
 290        Args:
 291            execution: The execution object.
 292        Returns:
 293            Command line arguments
 294        """
 295        cargs = []
 296        cargs.extend([
 297            "-antialias",
 298            self.antialias
 299        ])
 300        return cargs
 301
 302
 303@dataclasses.dataclass
 304class C3dSet:
 305    """
 306    -as: Assign image at the end of the stack to a variable
 307    
 308    Syntax: `-as var`
 309    
 310    Associates the image currently at the end of the stack with variable name
 311    'var'. This allows you to retrieve the image later on the command line using
 312    the **-push** command. The **-as** and **-push** commands are useful when
 313    you need to use a certain image more than once during a convert3d operation.
 314    For example, if you want to compute the distance transform of a binary image
 315    and mask it so that the values outside of the binary image region have value
 316    0, you would use the following command:
 317    
 318    c3d binary.img -as A -sdt -push A -times -o masked_distance.img.
 319    """
 320    set_: str
 321    """-as: Assign image at the end of the stack to a variable
 322    
 323    Syntax: `-as var`
 324    
 325    Associates the image currently at the end of the stack with variable name
 326    'var'. This allows you to retrieve the image later on the command line using
 327    the **-push** command. The **-as** and **-push** commands are useful when
 328    you need to use a certain image more than once during a convert3d operation.
 329    For example, if you want to compute the distance transform of a binary image
 330    and mask it so that the values outside of the binary image region have value
 331    0, you would use the following command:
 332    
 333    c3d binary.img -as A -sdt -push A -times -o masked_distance.img"""
 334    
 335    def run(
 336        self,
 337        execution: Execution,
 338    ) -> list[str]:
 339        """
 340        Build command line arguments. This method is called by the main command.
 341        
 342        Args:
 343            execution: The execution object.
 344        Returns:
 345            Command line arguments
 346        """
 347        cargs = []
 348        cargs.extend([
 349            "-as",
 350            self.set_
 351        ])
 352        return cargs
 353
 354
 355@dataclasses.dataclass
 356class C3dAsin:
 357    """
 358    No description found.
 359    """
 360    asin: str
 361    """No description found."""
 362    
 363    def run(
 364        self,
 365        execution: Execution,
 366    ) -> list[str]:
 367        """
 368        Build command line arguments. This method is called by the main command.
 369        
 370        Args:
 371            execution: The execution object.
 372        Returns:
 373            Command line arguments
 374        """
 375        cargs = []
 376        cargs.extend([
 377            "-asin",
 378            self.asin
 379        ])
 380        return cargs
 381
 382
 383@dataclasses.dataclass
 384class C3dAtan2:
 385    """
 386    -atan2: Voxelwise angle from sine and cosine
 387    
 388    Syntax: `-atan2`
 389    
 390    Computes the angle in radians from images containing sine and cosine. This
 391    is a voxel-wise operation. It requires two images on the stack (sine
 392    followed by cosine):
 393    
 394    c3d sin_theta.nii.gz cos_theta.nii.gz -atan2 -o theta.nii.gz.
 395    """
 396    atan2: str
 397    """-atan2: Voxelwise angle from sine and cosine
 398    
 399    Syntax: `-atan2`
 400    
 401    Computes the angle in radians from images containing sine and cosine. This
 402    is a voxel-wise operation. It requires two images on the stack (sine
 403    followed by cosine):
 404    
 405    c3d sin_theta.nii.gz cos_theta.nii.gz -atan2 -o theta.nii.gz"""
 406    
 407    def run(
 408        self,
 409        execution: Execution,
 410    ) -> list[str]:
 411        """
 412        Build command line arguments. This method is called by the main command.
 413        
 414        Args:
 415            execution: The execution object.
 416        Returns:
 417            Command line arguments
 418        """
 419        cargs = []
 420        cargs.extend([
 421            "-atan2",
 422            self.atan2
 423        ])
 424        return cargs
 425
 426
 427@dataclasses.dataclass
 428class C3dBackground:
 429    """
 430    -background: Specify background intensity
 431    
 432    Syntax: `-background <value> `
 433    
 434    Sets the background intensity for interpolation and other operations where
 435    some default background value is needed. Default is 0.
 436    """
 437    background: str
 438    """-background: Specify background intensity
 439    
 440    Syntax: `-background <value> `
 441    
 442    Sets the background intensity for interpolation and other operations where
 443    some default background value is needed. Default is 0."""
 444    
 445    def run(
 446        self,
 447        execution: Execution,
 448    ) -> list[str]:
 449        """
 450        Build command line arguments. This method is called by the main command.
 451        
 452        Args:
 453            execution: The execution object.
 454        Returns:
 455            Command line arguments
 456        """
 457        cargs = []
 458        cargs.extend([
 459            "-background",
 460            self.background
 461        ])
 462        return cargs
 463
 464
 465@dataclasses.dataclass
 466class C3dN4BiasCorrection:
 467    """
 468    -biascorr: Automatic MRI bias field correction
 469    
 470    Syntax: `-biascorr`
 471    
 472    Performs automatic bias field correction for MRI images. This feature uses
 473    the [N3 implementation in ITK by Dr. Tustison][4], based on the N3 algorithm
 474    by Sled et al.
 475    
 476    c3d mri.nii.gz -biascorr -o mricorr.nii.gz.
 477    """
 478    n4_bias_correction: str
 479    """-biascorr: Automatic MRI bias field correction
 480    
 481    Syntax: `-biascorr`
 482    
 483    Performs automatic bias field correction for MRI images. This feature uses
 484    the [N3 implementation in ITK by Dr. Tustison][4], based on the N3 algorithm
 485    by Sled et al.
 486    
 487    c3d mri.nii.gz -biascorr -o mricorr.nii.gz"""
 488    
 489    def run(
 490        self,
 491        execution: Execution,
 492    ) -> list[str]:
 493        """
 494        Build command line arguments. This method is called by the main command.
 495        
 496        Args:
 497            execution: The execution object.
 498        Returns:
 499            Command line arguments
 500        """
 501        cargs = []
 502        cargs.extend([
 503            "-biascorr",
 504            self.n4_bias_correction
 505        ])
 506        return cargs
 507
 508
 509@dataclasses.dataclass
 510class C3dBinarize:
 511    """
 512    -binarize: Convert image to binary
 513    
 514    Syntax: `-binarize`
 515    
 516    Converts an image to binary by mapping all background values (the background
 517    is 0 by default and can be changed by the option **-background**) to 0 and
 518    all non-background values to 1. The **-binarize** command is shorthand for
 519    the **-threshold** command.
 520    
 521    c3d test.img -binarize -o binary.img
 522    c3d -background 10 -binarize -o binary.img
 523    c3d test.img -threshold 10 10 0 1 // equivalent to above command.
 524    """
 525    binarize: str
 526    """-binarize: Convert image to binary
 527    
 528    Syntax: `-binarize`
 529    
 530    Converts an image to binary by mapping all background values (the background
 531    is 0 by default and can be changed by the option **-background**) to 0 and
 532    all non-background values to 1. The **-binarize** command is shorthand for
 533    the **-threshold** command.
 534    
 535    c3d test.img -binarize -o binary.img
 536    c3d -background 10 -binarize -o binary.img
 537    c3d test.img -threshold 10 10 0 1 // equivalent to above command"""
 538    
 539    def run(
 540        self,
 541        execution: Execution,
 542    ) -> list[str]:
 543        """
 544        Build command line arguments. This method is called by the main command.
 545        
 546        Args:
 547            execution: The execution object.
 548        Returns:
 549            Command line arguments
 550        """
 551        cargs = []
 552        cargs.extend([
 553            "-binarize",
 554            self.binarize
 555        ])
 556        return cargs
 557
 558
 559@dataclasses.dataclass
 560class C3dCanny:
 561    """
 562    -canny: Canny edge detector
 563    
 564    Syntax: `-canny <sigma_vector> <t_lower> <t_upper>`
 565    
 566    Performs edge detection on the last image on the stack using the Canny
 567    filter. The parameters are a vector of standard deviations defining the
 568    scale of the edges detected and lower and upper thresholds for edge
 569    selection. See documentation on the [ITK Canny Filter][14].
 570    """
 571    canny: str
 572    """-canny: Canny edge detector
 573    
 574    Syntax: `-canny <sigma_vector> <t_lower> <t_upper>`
 575    
 576    Performs edge detection on the last image on the stack using the Canny
 577    filter. The parameters are a vector of standard deviations defining the
 578    scale of the edges detected and lower and upper thresholds for edge
 579    selection. See documentation on the [ITK Canny Filter][14]."""
 580    
 581    def run(
 582        self,
 583        execution: Execution,
 584    ) -> list[str]:
 585        """
 586        Build command line arguments. This method is called by the main command.
 587        
 588        Args:
 589            execution: The execution object.
 590        Returns:
 591            Command line arguments
 592        """
 593        cargs = []
 594        cargs.extend([
 595            "-canny",
 596            self.canny
 597        ])
 598        return cargs
 599
 600
 601@dataclasses.dataclass
 602class C3dCeil:
 603    """
 604    -ceil: Round up image intensities
 605    
 606    Syntax: `-ceil `
 607    
 608    Each image intensity is replaced by the smallest integer larger or equal to
 609    it
 610    
 611    c3d input.img -ceil -o output.img.
 612    """
 613    ceil: str
 614    """-ceil: Round up image intensities
 615    
 616    Syntax: `-ceil `
 617    
 618    Each image intensity is replaced by the smallest integer larger or equal to
 619    it
 620    
 621    c3d input.img -ceil -o output.img"""
 622    
 623    def run(
 624        self,
 625        execution: Execution,
 626    ) -> list[str]:
 627        """
 628        Build command line arguments. This method is called by the main command.
 629        
 630        Args:
 631            execution: The execution object.
 632        Returns:
 633            Command line arguments
 634        """
 635        cargs = []
 636        cargs.extend([
 637            "-ceil",
 638            self.ceil
 639        ])
 640        return cargs
 641
 642
 643@dataclasses.dataclass
 644class C3dCentroid:
 645    """
 646    -centroid: Report centroid of foreground voxels
 647    
 648    Syntax: `-centroid`
 649    
 650    Reports the centroid, in physical coordinates, of all foreground voxels in
 651    the image.
 652    
 653    c3d binaryimage.img -centroid // centroid of all non-0 voxels
 654    c3d grayimage.img -thresh 1000 7000 1 0 -centroid 1 // centroid of all
 655    voxels in range 1000-7000
 656    c3d labelimage.img -thresh 5 5 1 0 -centroid // centroid of all voxels with
 657    label 5
 658    c3d labelimage.img -split -foreach -centroid -endfor // centroids of all
 659    labels (including 0).
 660    """
 661    centroid: str
 662    """-centroid: Report centroid of foreground voxels
 663    
 664    Syntax: `-centroid`
 665    
 666    Reports the centroid, in physical coordinates, of all foreground voxels in
 667    the image.
 668    
 669    c3d binaryimage.img -centroid // centroid of all non-0 voxels
 670    c3d grayimage.img -thresh 1000 7000 1 0 -centroid 1 // centroid of all
 671    voxels in range 1000-7000
 672    c3d labelimage.img -thresh 5 5 1 0 -centroid // centroid of all voxels with
 673    label 5
 674    c3d labelimage.img -split -foreach -centroid -endfor // centroids of all
 675    labels (including 0)"""
 676    
 677    def run(
 678        self,
 679        execution: Execution,
 680    ) -> list[str]:
 681        """
 682        Build command line arguments. This method is called by the main command.
 683        
 684        Args:
 685            execution: The execution object.
 686        Returns:
 687            Command line arguments
 688        """
 689        cargs = []
 690        cargs.extend([
 691            "-centroid",
 692            self.centroid
 693        ])
 694        return cargs
 695
 696
 697@dataclasses.dataclass
 698class C3dCentroidMark:
 699    """
 700    -centroid-mark: Mark the centroid of foreground voxels
 701    
 702    Syntax: `-centroid-mark <label>`
 703    
 704    Marks the centroid of the foreground voxels in an image. Unlike
 705    **-centroid**, this command does not print the centroid location, but marks
 706    the closest voxel in the image with the intensity **label**. The remaining
 707    voxels are assigned 0 intensity. Combined with -dilate, this can be used to
 708    mark centers of regions with spheres.
 709    
 710    c3d binaryimage.nii -centroid-mark -dilate 1 3x3x3
 711    c3d labelimage.nii -split -foreach -centroid-mark -endfor -merge -o
 712    centers.nii.
 713    """
 714    centroid_mark: str
 715    """-centroid-mark: Mark the centroid of foreground voxels
 716    
 717    Syntax: `-centroid-mark <label>`
 718    
 719    Marks the centroid of the foreground voxels in an image. Unlike
 720    **-centroid**, this command does not print the centroid location, but marks
 721    the closest voxel in the image with the intensity **label**. The remaining
 722    voxels are assigned 0 intensity. Combined with -dilate, this can be used to
 723    mark centers of regions with spheres.
 724    
 725    c3d binaryimage.nii -centroid-mark -dilate 1 3x3x3
 726    c3d labelimage.nii -split -foreach -centroid-mark -endfor -merge -o
 727    centers.nii"""
 728    
 729    def run(
 730        self,
 731        execution: Execution,
 732    ) -> list[str]:
 733        """
 734        Build command line arguments. This method is called by the main command.
 735        
 736        Args:
 737            execution: The execution object.
 738        Returns:
 739            Command line arguments
 740        """
 741        cargs = []
 742        cargs.extend([
 743            "-centroid-mark",
 744            self.centroid_mark
 745        ])
 746        return cargs
 747
 748
 749@dataclasses.dataclass
 750class C3dConnectedComponents:
 751    """
 752    -comp, -connected-components: Compute connected components
 753    
 754    Syntax: `-comp`
 755    
 756    Computes the connected components of a binary image. Each connected
 757    component is assigned an integer index. Indices are ordered by the size of
 758    the component, so the component assigned index 1 is the largest. The
 759    background is assigned index 0. To select the largest connected component,
 760    combine the call to **-comp** with a call to **-threshold**.
 761    
 762    c3d binary.img -comp -o comp.img
 763    c3d binary.img -comp -threshold 1 1 1 0 -o largest_comp.img.
 764    """
 765    connected_components: str
 766    """-comp, -connected-components: Compute connected components
 767    
 768    Syntax: `-comp`
 769    
 770    Computes the connected components of a binary image. Each connected
 771    component is assigned an integer index. Indices are ordered by the size of
 772    the component, so the component assigned index 1 is the largest. The
 773    background is assigned index 0. To select the largest connected component,
 774    combine the call to **-comp** with a call to **-threshold**.
 775    
 776    c3d binary.img -comp -o comp.img
 777    c3d binary.img -comp -threshold 1 1 1 0 -o largest_comp.img"""
 778    
 779    def run(
 780        self,
 781        execution: Execution,
 782    ) -> list[str]:
 783        """
 784        Build command line arguments. This method is called by the main command.
 785        
 786        Args:
 787            execution: The execution object.
 788        Returns:
 789            Command line arguments
 790        """
 791        cargs = []
 792        cargs.extend([
 793            "-connected-components",
 794            self.connected_components
 795        ])
 796        return cargs
 797
 798
 799@dataclasses.dataclass
 800class C3dClear:
 801    """
 802    -clear: Clear the image stack
 803    
 804    Syntax: `-clear`
 805    
 806    Clears the image stack. Images assigned a name with the **-as** command will
 807    remain in memory.
 808    """
 809    clear_: str
 810    """-clear: Clear the image stack
 811    
 812    Syntax: `-clear`
 813    
 814    Clears the image stack. Images assigned a name with the **-as** command will
 815    remain in memory."""
 816    
 817    def run(
 818        self,
 819        execution: Execution,
 820    ) -> list[str]:
 821        """
 822        Build command line arguments. This method is called by the main command.
 823        
 824        Args:
 825            execution: The execution object.
 826        Returns:
 827            Command line arguments
 828        """
 829        cargs = []
 830        cargs.extend([
 831            "-clear",
 832            self.clear_
 833        ])
 834        return cargs
 835
 836
 837@dataclasses.dataclass
 838class C3dClip:
 839    """
 840    -clip: Clip image intensity to range
 841    
 842    Syntax: `-clip iMin iMax`
 843    
 844    Clips image intensities, so that the values below *iMin* are converted to
 845    *iMin* and values greater than *iMax* are converted to *iMax*. This is
 846    useful for eliminating hyperintensities in images. Values *iMin* and *iMax*
 847    are intensity specifications (see below).
 848    
 849    c3d mri.img -clip 1000 8000 -o mriclip01.img // Clips below and above
 850    c3d mri.img -clip -inf 8000 -o mriclip02.img // Clips above only
 851    c3d mri.img -clip -inf 95% -o mriclip03.img // Clips at 95th percentile.
 852    """
 853    clip: str
 854    """-clip: Clip image intensity to range
 855    
 856    Syntax: `-clip iMin iMax`
 857    
 858    Clips image intensities, so that the values below *iMin* are converted to
 859    *iMin* and values greater than *iMax* are converted to *iMax*. This is
 860    useful for eliminating hyperintensities in images. Values *iMin* and *iMax*
 861    are intensity specifications (see below).
 862    
 863    c3d mri.img -clip 1000 8000 -o mriclip01.img // Clips below and above
 864    c3d mri.img -clip -inf 8000 -o mriclip02.img // Clips above only
 865    c3d mri.img -clip -inf 95% -o mriclip03.img // Clips at 95th percentile"""
 866    
 867    def run(
 868        self,
 869        execution: Execution,
 870    ) -> list[str]:
 871        """
 872        Build command line arguments. This method is called by the main command.
 873        
 874        Args:
 875            execution: The execution object.
 876        Returns:
 877            Command line arguments
 878        """
 879        cargs = []
 880        cargs.extend([
 881            "-clip",
 882            self.clip
 883        ])
 884        return cargs
 885
 886
 887@dataclasses.dataclass
 888class C3dColorMap:
 889    """
 890    -color-map, -colormap: Convert scalar image to RGB using color map
 891    
 892    Syntax: `-color-map <ColormapName> [min max]`
 893    
 894    Converts a scalar image to a color (RGB) image using a specified color map.
 895    The output of the command are three images, containing the red, green and
 896    blue channels of the RGB image. The mapping uses the range of the input
 897    image, e.g., using the **jet** color map, the lowest intensity pixel in the
 898    image will be mapped to blue, and the highest intesnity pixel will be mapped
 899    to red. The admissible color maps are
 900    **hot,cool,spring,summer,autumn,winter,copper,jet,hsv,red,green,blue,grey,overunder**.
 901    The command can be used with the -omc command to write RGB images. The
 902    example below generates a PNG image from a slice in a scalar image.
 903    
 904    c3d scalar.nii.gz -slice z 50% -flip y -color-map jet -type uchar -omc
 905    colorslice.png
 906    
 907    By default the full image intensity range is mapped. The optional **min**
 908    and **max** parameters can be used to set the range of the color map.
 909    
 910    c3d scalar.nii.gz -slice z 50% -flip y -color-map jet 0 1 -type uchar -omc
 911    colorslice.png.
 912    """
 913    color_map: str
 914    """-color-map, -colormap: Convert scalar image to RGB using color map
 915    
 916    Syntax: `-color-map <ColormapName> [min max]`
 917    
 918    Converts a scalar image to a color (RGB) image using a specified color map.
 919    The output of the command are three images, containing the red, green and
 920    blue channels of the RGB image. The mapping uses the range of the input
 921    image, e.g., using the **jet** color map, the lowest intensity pixel in the
 922    image will be mapped to blue, and the highest intesnity pixel will be mapped
 923    to red. The admissible color maps are
 924    **hot,cool,spring,summer,autumn,winter,copper,jet,hsv,red,green,blue,grey,overunder**.
 925    The command can be used with the -omc command to write RGB images. The
 926    example below generates a PNG image from a slice in a scalar image.
 927    
 928    c3d scalar.nii.gz -slice z 50% -flip y -color-map jet -type uchar -omc
 929    colorslice.png
 930    
 931    By default the full image intensity range is mapped. The optional **min**
 932    and **max** parameters can be used to set the range of the color map.
 933    
 934    c3d scalar.nii.gz -slice z 50% -flip y -color-map jet 0 1 -type uchar -omc
 935    colorslice.png"""
 936    
 937    def run(
 938        self,
 939        execution: Execution,
 940    ) -> list[str]:
 941        """
 942        Build command line arguments. This method is called by the main command.
 943        
 944        Args:
 945            execution: The execution object.
 946        Returns:
 947            Command line arguments
 948        """
 949        cargs = []
 950        cargs.extend([
 951            "-colormap",
 952            self.color_map
 953        ])
 954        return cargs
 955
 956
 957@dataclasses.dataclass
 958class C3dCompress:
 959    """
 960    -compress, -no-compress: Enable/disable compression for some image files
 961    
 962    Syntax: `-compress` or `-no-compress`
 963    
 964    Turns on compressing for image file formats that support it. For some file
 965    formats, like NIFTI (.nii), compression is enabled automatically when the
 966    filename includes the **.gz** extension. For other formats, like MetaImage,
 967    you need to specify **-compress** to enable compression. The following two
 968    commands save the image as compressed NIFTI and MetaImage files:
 969    
 970    c3d input.nii -o output.nii.gz
 971    c3d input.nii -compress -o output.mha.
 972    """
 973    compress: str
 974    """-compress, -no-compress: Enable/disable compression for some image files
 975    
 976    Syntax: `-compress` or `-no-compress`
 977    
 978    Turns on compressing for image file formats that support it. For some file
 979    formats, like NIFTI (.nii), compression is enabled automatically when the
 980    filename includes the **.gz** extension. For other formats, like MetaImage,
 981    you need to specify **-compress** to enable compression. The following two
 982    commands save the image as compressed NIFTI and MetaImage files:
 983    
 984    c3d input.nii -o output.nii.gz
 985    c3d input.nii -compress -o output.mha"""
 986    
 987    def run(
 988        self,
 989        execution: Execution,
 990    ) -> list[str]:
 991        """
 992        Build command line arguments. This method is called by the main command.
 993        
 994        Args:
 995            execution: The execution object.
 996        Returns:
 997            Command line arguments
 998        """
 999        cargs = []
1000        cargs.extend([
1001            "-compress",
1002            self.compress
1003        ])
1004        return cargs
1005
1006
1007@dataclasses.dataclass
1008class C3dNoCompress:
1009    """
1010    -compress, -no-compress: Enable/disable compression for some image files
1011    
1012    Syntax: `-compress` or `-no-compress`
1013    
1014    Turns on compressing for image file formats that support it. For some file
1015    formats, like NIFTI (.nii), compression is enabled automatically when the
1016    filename includes the **.gz** extension. For other formats, like MetaImage,
1017    you need to specify **-compress** to enable compression. The following two
1018    commands save the image as compressed NIFTI and MetaImage files:
1019    
1020    c3d input.nii -o output.nii.gz
1021    c3d input.nii -compress -o output.mha.
1022    """
1023    no_compress: str
1024    """-compress, -no-compress: Enable/disable compression for some image files
1025    
1026    Syntax: `-compress` or `-no-compress`
1027    
1028    Turns on compressing for image file formats that support it. For some file
1029    formats, like NIFTI (.nii), compression is enabled automatically when the
1030    filename includes the **.gz** extension. For other formats, like MetaImage,
1031    you need to specify **-compress** to enable compression. The following two
1032    commands save the image as compressed NIFTI and MetaImage files:
1033    
1034    c3d input.nii -o output.nii.gz
1035    c3d input.nii -compress -o output.mha"""
1036    
1037    def run(
1038        self,
1039        execution: Execution,
1040    ) -> list[str]:
1041        """
1042        Build command line arguments. This method is called by the main command.
1043        
1044        Args:
1045            execution: The execution object.
1046        Returns:
1047            Command line arguments
1048        """
1049        cargs = []
1050        cargs.extend([
1051            "-no-compress",
1052            self.no_compress
1053        ])
1054        return cargs
1055
1056
1057@dataclasses.dataclass
1058class C3dConv:
1059    """
1060    -conv: Convolution
1061    
1062    Syntax `-conv`
1063    
1064    Performs convolution between the last two images on the stack. The
1065    convolution is performed using the Fourier transform. The result is an image
1066    of the same dimensions as the first image. For more details, see ["FFT Based
1067    Convolution" by Gaetan Lehmann][Lehmann].
1068    
1069    c3d image.nii kernel.nii -conv -o result.nii
1070    
1071    
1072    [Lehmann]: https://hdl.handle.net/10380/3154.
1073    """
1074    conv: str
1075    """-conv: Convolution
1076    
1077    Syntax `-conv`
1078    
1079    Performs convolution between the last two images on the stack. The
1080    convolution is performed using the Fourier transform. The result is an image
1081    of the same dimensions as the first image. For more details, see ["FFT Based
1082    Convolution" by Gaetan Lehmann][Lehmann].
1083    
1084    c3d image.nii kernel.nii -conv -o result.nii
1085    
1086    
1087    [Lehmann]: https://hdl.handle.net/10380/3154"""
1088    
1089    def run(
1090        self,
1091        execution: Execution,
1092    ) -> list[str]:
1093        """
1094        Build command line arguments. This method is called by the main command.
1095        
1096        Args:
1097            execution: The execution object.
1098        Returns:
1099            Command line arguments
1100        """
1101        cargs = []
1102        cargs.extend([
1103            "-conv",
1104            self.conv
1105        ])
1106        return cargs
1107
1108
1109@dataclasses.dataclass
1110class C3dCoordinateMapVoxel:
1111    """
1112    -cmv, -coordinate-map-voxel: Generate voxel coordinate maps (voxel units)
1113    
1114    Syntax: `-cmv`
1115    
1116    For a *N*-dimensional image, replaces the last image on the stack with *N*
1117    images. The *k*-th output image at each voxel contains the $k$-th coordinate
1118    of that voxel, in voxel units.
1119    
1120    c3d image.nii -cmv -oo coordmap%d.nii.gz
1121    
1122    One can use this command to split a brain segmentation image into a left
1123    hemisphere segmentation and a right hemisphere segmentation (assuming the X
1124    coordinate corresponds to the right-left axis)
1125    
1126    c3d seg.nii -as SEG -cmv -pop -pop -thresh 50% inf 1 0 -as MASK \
1127    -push SEG -times -o seg_left.nii.gz \
1128    -push MASK -replace 1 0 0 1 \
1129    -push SEG -times -o seg_right.nii.gz.
1130    """
1131    coordinate_map_voxel: str
1132    """-cmv, -coordinate-map-voxel: Generate voxel coordinate maps (voxel units)
1133    
1134    Syntax: `-cmv`
1135    
1136    For a *N*-dimensional image, replaces the last image on the stack with *N*
1137    images. The *k*-th output image at each voxel contains the $k$-th coordinate
1138    of that voxel, in voxel units.
1139    
1140    c3d image.nii -cmv -oo coordmap%d.nii.gz
1141    
1142    One can use this command to split a brain segmentation image into a left
1143    hemisphere segmentation and a right hemisphere segmentation (assuming the X
1144    coordinate corresponds to the right-left axis)
1145    
1146    c3d seg.nii -as SEG -cmv -pop -pop -thresh 50% inf 1 0 -as MASK \
1147    -push SEG -times -o seg_left.nii.gz \
1148    -push MASK -replace 1 0 0 1 \
1149    -push SEG -times -o seg_right.nii.gz"""
1150    
1151    def run(
1152        self,
1153        execution: Execution,
1154    ) -> list[str]:
1155        """
1156        Build command line arguments. This method is called by the main command.
1157        
1158        Args:
1159            execution: The execution object.
1160        Returns:
1161            Command line arguments
1162        """
1163        cargs = []
1164        cargs.extend([
1165            "-coordinate-map-voxel",
1166            self.coordinate_map_voxel
1167        ])
1168        return cargs
1169
1170
1171@dataclasses.dataclass
1172class C3dCoordinateMapPhysical:
1173    """
1174    -cmp, -coordinate-map-physical: Generate voxel coordinate maps (voxel units)
1175    
1176    Syntax: `-cmp`
1177    
1178    This command is similar to **-cmv** (**-coordinate-map-voxel**), but the
1179    output will contain the physical coordinates of the voxels, in the NIFTI
1180    (RAS) coordinate frame.
1181    """
1182    coordinate_map_physical: str
1183    """-cmp, -coordinate-map-physical: Generate voxel coordinate maps (voxel
1184    units)
1185    
1186    Syntax: `-cmp`
1187    
1188    This command is similar to **-cmv** (**-coordinate-map-voxel**), but the
1189    output will contain the physical coordinates of the voxels, in the NIFTI
1190    (RAS) coordinate frame."""
1191    
1192    def run(
1193        self,
1194        execution: Execution,
1195    ) -> list[str]:
1196        """
1197        Build command line arguments. This method is called by the main command.
1198        
1199        Args:
1200            execution: The execution object.
1201        Returns:
1202            Command line arguments
1203        """
1204        cargs = []
1205        cargs.extend([
1206            "-coordinate-map-physical",
1207            self.coordinate_map_physical
1208        ])
1209        return cargs
1210
1211
1212@dataclasses.dataclass
1213class C3dCopyTransform:
1214    """
1215    -copy-transform: Copy header information
1216    
1217    Syntax: `-copy-transform`
1218    
1219    Copies the image header, specifically the image to physical space transform
1220    (origin, spacing, direction cosines), from the first image (reference) to
1221    the second image (target). This is best done with NIFTI images, which store
1222    this information well. In the example below, *out.nii* will have the same
1223    header as *first.nii* and the same intensities as *second.nii*.
1224    
1225    c3d first.nii second.nii -copy-transform -o out.nii.
1226    """
1227    copy_transform: str
1228    """-copy-transform: Copy header information
1229    
1230    Syntax: `-copy-transform`
1231    
1232    Copies the image header, specifically the image to physical space transform
1233    (origin, spacing, direction cosines), from the first image (reference) to
1234    the second image (target). This is best done with NIFTI images, which store
1235    this information well. In the example below, *out.nii* will have the same
1236    header as *first.nii* and the same intensities as *second.nii*.
1237    
1238    c3d first.nii second.nii -copy-transform -o out.nii"""
1239    
1240    def run(
1241        self,
1242        execution: Execution,
1243    ) -> list[str]:
1244        """
1245        Build command line arguments. This method is called by the main command.
1246        
1247        Args:
1248            execution: The execution object.
1249        Returns:
1250            Command line arguments
1251        """
1252        cargs = []
1253        cargs.extend([
1254            "-copy-transform",
1255            self.copy_transform
1256        ])
1257        return cargs
1258
1259
1260@dataclasses.dataclass
1261class C3dCos:
1262    """
1263    No description found.
1264    """
1265    cos: str
1266    """No description found."""
1267    
1268    def run(
1269        self,
1270        execution: Execution,
1271    ) -> list[str]:
1272        """
1273        Build command line arguments. This method is called by the main command.
1274        
1275        Args:
1276            execution: The execution object.
1277        Returns:
1278            Command line arguments
1279        """
1280        cargs = []
1281        cargs.extend([
1282            "-cos",
1283            self.cos
1284        ])
1285        return cargs
1286
1287
1288@dataclasses.dataclass
1289class C3dCreate:
1290    """
1291    -create: Generate blank image
1292    
1293    Syntax: `-create dimensions voxel_size`
1294    
1295    Creates a new blank image with specified dimensions and voxel size, and
1296    places it at the end of the stack. The image is set to the current
1297    background value, which is 0 by default but can be overwritten with the
1298    **-background** command. The origin of the image can be changed with the
1299    **-origin** command.
1300    
1301    c3d -create 256x256x160 1x1x1mm -o newimage.img
1302    c3d -background 128 -create 256x256x160 1x1x1mm -origin 128x128x80mm -o
1303    newimage.img.
1304    """
1305    create: str
1306    """-create: Generate blank image
1307    
1308    Syntax: `-create dimensions voxel_size`
1309    
1310    Creates a new blank image with specified dimensions and voxel size, and
1311    places it at the end of the stack. The image is set to the current
1312    background value, which is 0 by default but can be overwritten with the
1313    **-background** command. The origin of the image can be changed with the
1314    **-origin** command.
1315    
1316    c3d -create 256x256x160 1x1x1mm -o newimage.img
1317    c3d -background 128 -create 256x256x160 1x1x1mm -origin 128x128x80mm -o
1318    newimage.img"""
1319    
1320    def run(
1321        self,
1322        execution: Execution,
1323    ) -> list[str]:
1324        """
1325        Build command line arguments. This method is called by the main command.
1326        
1327        Args:
1328            execution: The execution object.
1329        Returns:
1330            Command line arguments
1331        """
1332        cargs = []
1333        cargs.extend([
1334            "-create",
1335            self.create
1336        ])
1337        return cargs
1338
1339
1340@dataclasses.dataclass
1341class C3dDicomSeriesList:
1342    """
1343    -dicom-series-list: List image series in a DICOM directory
1344    
1345    Syntax: `-dicom-series-list <directory>
1346    
1347    Prints out a table of DICOM series ids and corresponding image information
1348    to standard output.
1349    """
1350    dicom_series_list: str
1351    """-dicom-series-list: List image series in a DICOM directory
1352    
1353    Syntax: `-dicom-series-list <directory>
1354    
1355    Prints out a table of DICOM series ids and corresponding image information
1356    to standard output."""
1357    
1358    def run(
1359        self,
1360        execution: Execution,
1361    ) -> list[str]:
1362        """
1363        Build command line arguments. This method is called by the main command.
1364        
1365        Args:
1366            execution: The execution object.
1367        Returns:
1368            Command line arguments
1369        """
1370        cargs = []
1371        cargs.extend([
1372            "-dicom-series-list",
1373            self.dicom_series_list
1374        ])
1375        return cargs
1376
1377
1378@dataclasses.dataclass
1379class C3dDicomSeriesRead:
1380    """
1381    -dicom-series-read: Read a DICOM image series
1382    
1383    Syntax: `-dicom-series-read <directory> <series_id>`
1384    
1385    Imports a specific DICOM image series from a directory containing DICOM
1386    files. The **directory** parameter may also point to one of the DICOM files
1387    in the directory.
1388    The **seried_id** is a string identifier for the series that can be obtained
1389    by calling **-dicom-series-list**.
1390    """
1391    dicom_series_read: str
1392    """-dicom-series-read: Read a DICOM image series
1393    
1394    Syntax: `-dicom-series-read <directory> <series_id>`
1395    
1396    Imports a specific DICOM image series from a directory containing DICOM
1397    files. The **directory** parameter may also point to one of the DICOM files
1398    in the directory.
1399    The **seried_id** is a string identifier for the series that can be obtained
1400    by calling **-dicom-series-list**"""
1401    
1402    def run(
1403        self,
1404        execution: Execution,
1405    ) -> list[str]:
1406        """
1407        Build command line arguments. This method is called by the main command.
1408        
1409        Args:
1410            execution: The execution object.
1411        Returns:
1412            Command line arguments
1413        """
1414        cargs = []
1415        cargs.extend([
1416            "-dicom-series-read",
1417            self.dicom_series_read
1418        ])
1419        return cargs
1420
1421
1422@dataclasses.dataclass
1423class C3dDilate:
1424    """
1425    -dilate: Binary dilation
1426    
1427    Syntax: `-dilate <label> <radius_vector>`
1428    
1429    Applies the dilation [mathematical morphology][5] operation to a binary
1430    image. The first parameter is the intensity value of the object that is to
1431    be dilated. The second is the radius of the dilation structuring element in
1432    3D.
1433    
1434    c3d binary.img -dilate 255 3x3x3vox -o newimage.img.
1435    """
1436    dilate: str
1437    """-dilate: Binary dilation
1438    
1439    Syntax: `-dilate <label> <radius_vector>`
1440    
1441    Applies the dilation [mathematical morphology][5] operation to a binary
1442    image. The first parameter is the intensity value of the object that is to
1443    be dilated. The second is the radius of the dilation structuring element in
1444    3D.
1445    
1446    c3d binary.img -dilate 255 3x3x3vox -o newimage.img"""
1447    
1448    def run(
1449        self,
1450        execution: Execution,
1451    ) -> list[str]:
1452        """
1453        Build command line arguments. This method is called by the main command.
1454        
1455        Args:
1456            execution: The execution object.
1457        Returns:
1458            Command line arguments
1459        """
1460        cargs = []
1461        cargs.extend([
1462            "-dilate",
1463            self.dilate
1464        ])
1465        return cargs
1466
1467
1468@dataclasses.dataclass
1469class C3dDivide:
1470    """
1471    -divide: Voxelwise image division
1472    
1473    Syntax: `-divide`
1474    
1475    Divides one image by another. For instance to compute C = A / B, use the
1476    command
1477    
1478    c3d A.img B.img -divide -o C.img
1479    
1480    Divison may generate infinite and not-a-number (NaN) values if B contains
1481    zeros. You can use **-replace** to get rid of these values
1482    
1483    c3d A.img B.img -divide -replace inf 1000 -inf -1000 NaN 0 -o C2.img.
1484    """
1485    divide: str
1486    """-divide: Voxelwise image division
1487    
1488    Syntax: `-divide`
1489    
1490    Divides one image by another. For instance to compute C = A / B, use the
1491    command
1492    
1493    c3d A.img B.img -divide -o C.img
1494    
1495    Divison may generate infinite and not-a-number (NaN) values if B contains
1496    zeros. You can use **-replace** to get rid of these values
1497    
1498    c3d A.img B.img -divide -replace inf 1000 -inf -1000 NaN 0 -o C2.img"""
1499    
1500    def run(
1501        self,
1502        execution: Execution,
1503    ) -> list[str]:
1504        """
1505        Build command line arguments. This method is called by the main command.
1506        
1507        Args:
1508            execution: The execution object.
1509        Returns:
1510            Command line arguments
1511        """
1512        cargs = []
1513        cargs.extend([
1514            "-divide",
1515            self.divide
1516        ])
1517        return cargs
1518
1519
1520@dataclasses.dataclass
1521class C3dDuplicate:
1522    """
1523    -dup: Duplicate the last image on the stack
1524    
1525    Syntax: `-dup`
1526    
1527    Duplicates the image at the end of the stack. This is equivalent to **-as
1528    var -push var**, but shorter. An example is when you want to pass an image
1529    as both arguments to a binary operator, e.g., computing the square of the
1530    image intensity:
1531    
1532    c3d input.img -dup -times -o square.img
1533    
1534    ### Commands: Voxelwise Calculations.
1535    """
1536    duplicate: str
1537    """-dup: Duplicate the last image on the stack
1538    
1539    Syntax: `-dup`
1540    
1541    Duplicates the image at the end of the stack. This is equivalent to **-as
1542    var -push var**, but shorter. An example is when you want to pass an image
1543    as both arguments to a binary operator, e.g., computing the square of the
1544    image intensity:
1545    
1546    c3d input.img -dup -times -o square.img
1547    
1548    ### Commands: Voxelwise Calculations"""
1549    
1550    def run(
1551        self,
1552        execution: Execution,
1553    ) -> list[str]:
1554        """
1555        Build command line arguments. This method is called by the main command.
1556        
1557        Args:
1558            execution: The execution object.
1559        Returns:
1560            Command line arguments
1561        """
1562        cargs = []
1563        cargs.extend([
1564            "-dup",
1565            self.duplicate
1566        ])
1567        return cargs
1568
1569
1570@dataclasses.dataclass
1571class C3dEndaccum:
1572    """
1573    -accum, -endaccum: Accumulate operations over all images
1574    
1575    Syntax: `-accum command-list -endaccum`
1576    
1577    Apply a binary operation (such as addition or multiplication) to all the
1578    images on the stack in a cumulative fashion. The command(s) will be applied
1579    to the last and second-to-last images on the stack, then to the result of
1580    this operation and the third-to-last image on the stack and so on. Below is
1581    the example of using the command to add multiple images.
1582    
1583    c3d image*.nii -accum -add -endaccum -o sum.nii.
1584    """
1585    endaccum: str
1586    """-accum, -endaccum: Accumulate operations over all images
1587    
1588    Syntax: `-accum command-list -endaccum`
1589    
1590    Apply a binary operation (such as addition or multiplication) to all the
1591    images on the stack in a cumulative fashion. The command(s) will be applied
1592    to the last and second-to-last images on the stack, then to the result of
1593    this operation and the third-to-last image on the stack and so on. Below is
1594    the example of using the command to add multiple images.
1595    
1596    c3d image*.nii -accum -add -endaccum -o sum.nii"""
1597    
1598    def run(
1599        self,
1600        execution: Execution,
1601    ) -> list[str]:
1602        """
1603        Build command line arguments. This method is called by the main command.
1604        
1605        Args:
1606            execution: The execution object.
1607        Returns:
1608            Command line arguments
1609        """
1610        cargs = []
1611        cargs.extend([
1612            "-endaccum",
1613            self.endaccum
1614        ])
1615        return cargs
1616
1617
1618@dataclasses.dataclass
1619class C3dEndfor:
1620    """
1621    -foreach, -endfor: Loop commands over all images on the stack
1622    
1623    Syntax: `-foreach commands-list -endfor`
1624    
1625    This command forces the commands between **-foreach** and **-endfor** to be
1626    applied to every image on the stack. The main use of this command is to
1627    automate processing of multiple datasets. For example,
1628    
1629    c3d epi*.nii -foreach -smooth 3mm -endfor -oo epism%03d.nii.
1630    """
1631    endfor: str
1632    """-foreach, -endfor: Loop commands over all images on the stack
1633    
1634    Syntax: `-foreach commands-list -endfor`
1635    
1636    This command forces the commands between **-foreach** and **-endfor** to be
1637    applied to every image on the stack. The main use of this command is to
1638    automate processing of multiple datasets. For example,
1639    
1640    c3d epi*.nii -foreach -smooth 3mm -endfor -oo epism%03d.nii"""
1641    
1642    def run(
1643        self,
1644        execution: Execution,
1645    ) -> list[str]:
1646        """
1647        Build command line arguments. This method is called by the main command.
1648        
1649        Args:
1650            execution: The execution object.
1651        Returns:
1652            Command line arguments
1653        """
1654        cargs = []
1655        cargs.extend([
1656            "-endfor",
1657            self.endfor
1658        ])
1659        return cargs
1660
1661
1662@dataclasses.dataclass
1663class C3dErode:
1664    """
1665    -erode: Binary erosion
1666    
1667    Syntax: `-erode <label> <radius_vector>`
1668    
1669    Applies erosion [mathematical morphology][5] operation to a binary image.
1670    The first parameter is the intensity value of the object that is to be
1671    eroded. The second is the radius of the erosion structuring element in 3D.
1672    
1673    c3d binary.img -erode 255 3x3x3vox -o newimage.img.
1674    """
1675    erode: str
1676    """-erode: Binary erosion
1677    
1678    Syntax: `-erode <label> <radius_vector>`
1679    
1680    Applies erosion [mathematical morphology][5] operation to a binary image.
1681    The first parameter is the intensity value of the object that is to be
1682    eroded. The second is the radius of the erosion structuring element in 3D.
1683    
1684    c3d binary.img -erode 255 3x3x3vox -o newimage.img"""
1685    
1686    def run(
1687        self,
1688        execution: Execution,
1689    ) -> list[str]:
1690        """
1691        Build command line arguments. This method is called by the main command.
1692        
1693        Args:
1694            execution: The execution object.
1695        Returns:
1696            Command line arguments
1697        """
1698        cargs = []
1699        cargs.extend([
1700            "-erode",
1701            self.erode
1702        ])
1703        return cargs
1704
1705
1706@dataclasses.dataclass
1707class C3dErf:
1708    """
1709    -erf: Standard error function
1710    
1711    Syntax: `-erf mu sigma`
1712    
1713    Computes the standard error function. This is useful for applying soft
1714    thresholds. The function computes y = erf((x - mu)/sigma).
1715    
1716    c3d input.img -erf 5 2 -o erf.img.
1717    """
1718    erf: str
1719    """-erf: Standard error function
1720    
1721    Syntax: `-erf mu sigma`
1722    
1723    Computes the standard error function. This is useful for applying soft
1724    thresholds. The function computes y = erf((x - mu)/sigma).
1725    
1726    c3d input.img -erf 5 2 -o erf.img"""
1727    
1728    def run(
1729        self,
1730        execution: Execution,
1731    ) -> list[str]:
1732        """
1733        Build command line arguments. This method is called by the main command.
1734        
1735        Args:
1736            execution: The execution object.
1737        Returns:
1738            Command line arguments
1739        """
1740        cargs = []
1741        cargs.extend([
1742            "-erf",
1743            self.erf
1744        ])
1745        return cargs
1746
1747
1748@dataclasses.dataclass
1749class C3dExp:
1750    """
1751    -exp: Voxelwise natural exponent
1752    
1753    Syntax: `-exp`
1754    
1755    Computes exponent of each voxel in the last image on the stack.
1756    
1757    c3d input.img -exp -o output.img.
1758    """
1759    exp: str
1760    """-exp: Voxelwise natural exponent
1761    
1762    Syntax: `-exp`
1763    
1764    Computes exponent of each voxel in the last image on the stack.
1765    
1766    c3d input.img -exp -o output.img"""
1767    
1768    def run(
1769        self,
1770        execution: Execution,
1771    ) -> list[str]:
1772        """
1773        Build command line arguments. This method is called by the main command.
1774        
1775        Args:
1776            execution: The execution object.
1777        Returns:
1778            Command line arguments
1779        """
1780        cargs = []
1781        cargs.extend([
1782            "-exp",
1783            self.exp
1784        ])
1785        return cargs
1786
1787
1788@dataclasses.dataclass
1789class C3dExportPatches:
1790    """
1791    -export-patches, -xp: Fixed size patch sampling from masked regions
1792    
1793    Syntax: `-export-patches <outfile> <radius_vector> <frequency>`
1794    
1795    See also: **-export-patches-aug (-xpa)** command, which provides data
1796    augmentation for deep learning.
1797    
1798    This command samples patches from a region of a ND image and stores them
1799    into a data file that can be read easily in other software, for example,
1800    NumPy. This is useful for generating training data for machine learning
1801    projects. Multiple "channels" can be sampled.
1802    
1803    c3d chan1.nii chan2.nii chan3.nii mask.nii -xp samples.dat 4x4x4 100
1804    
1805    This command will sample the three images chan1, chan2, chan3 at foreground
1806    voxels in the mask. Voxels in the mask foreground region are sampled
1807    randomly, following a uniform distribution. The value of 100 means that
1808    every 100-th voxel, on average, is sampled. The radius 4x4x4 means that
1809    patches of size 9x9x9 will be generated. For each sampled voxel, the sampled
1810    intensity data is represented as a 3x9x9x9 array in this example.
1811    
1812    To read these samples in NumPy use the following code
1813    
1814    dims = (9,9,9) # Patch dimensions
1815    k = 3 # Number of channels
1816    bps = (4 * k * reduce(mul, dims, 1)) # Bytes per sample
1817    np = os.path.getsize(fname) // bps # Number of samples
1818    arr = numpy.memmap(fname,'float32','r',shape=(np,k) + dims)
1819    
1820    It is also possible to visualize the extracted samples in ITK-SNAP by
1821    reading them as a raw image, with dimensions equal to the dimensions of the
1822    patch, and the z-dimension multiplied by the number of samples.
1823    
1824    The command can also be used to extract entire structures. For example, if
1825    we have a binary segmentation of a lesion of an approximately known size in
1826    an MRI scan, we can extract a patch of given size centered on this lesion,
1827    as follows:
1828    
1829    c3d mri.nii lesion_seg.nii -centroid-mark 1 -xp single_sample.dat 50x50x20 1
1830    
1831    In the above example, **-centroid-mark** transforms the lesion segmentation
1832    into a single-voxel mask, from which the sample from the MRI is taken.
1833    """
1834    export_patches: str
1835    """-export-patches, -xp: Fixed size patch sampling from masked regions
1836    
1837    Syntax: `-export-patches <outfile> <radius_vector> <frequency>`
1838    
1839    See also: **-export-patches-aug (-xpa)** command, which provides data
1840    augmentation for deep learning.
1841    
1842    This command samples patches from a region of a ND image and stores them
1843    into a data file that can be read easily in other software, for example,
1844    NumPy. This is useful for generating training data for machine learning
1845    projects. Multiple "channels" can be sampled.
1846    
1847    c3d chan1.nii chan2.nii chan3.nii mask.nii -xp samples.dat 4x4x4 100
1848    
1849    This command will sample the three images chan1, chan2, chan3 at foreground
1850    voxels in the mask. Voxels in the mask foreground region are sampled
1851    randomly, following a uniform distribution. The value of 100 means that
1852    every 100-th voxel, on average, is sampled. The radius 4x4x4 means that
1853    patches of size 9x9x9 will be generated. For each sampled voxel, the sampled
1854    intensity data is represented as a 3x9x9x9 array in this example.
1855    
1856    To read these samples in NumPy use the following code
1857    
1858    dims = (9,9,9) # Patch dimensions
1859    k = 3 # Number of channels
1860    bps = (4 * k * reduce(mul, dims, 1)) # Bytes per sample
1861    np = os.path.getsize(fname) // bps # Number of samples
1862    arr = numpy.memmap(fname,'float32','r',shape=(np,k) + dims)
1863    
1864    It is also possible to visualize the extracted samples in ITK-SNAP by
1865    reading them as a raw image, with dimensions equal to the dimensions of the
1866    patch, and the z-dimension multiplied by the number of samples.
1867    
1868    The command can also be used to extract entire structures. For example, if
1869    we have a binary segmentation of a lesion of an approximately known size in
1870    an MRI scan, we can extract a patch of given size centered on this lesion,
1871    as follows:
1872    
1873    c3d mri.nii lesion_seg.nii -centroid-mark 1 -xp single_sample.dat 50x50x20 1
1874    
1875    In the above example, **-centroid-mark** transforms the lesion segmentation
1876    into a single-voxel mask, from which the sample from the MRI is taken."""
1877    
1878    def run(
1879        self,
1880        execution: Execution,
1881    ) -> list[str]:
1882        """
1883        Build command line arguments. This method is called by the main command.
1884        
1885        Args:
1886            execution: The execution object.
1887        Returns:
1888            Command line arguments
1889        """
1890        cargs = []
1891        cargs.extend([
1892            "-export-patches",
1893            self.export_patches
1894        ])
1895        return cargs
1896
1897
1898@dataclasses.dataclass
1899class C3dExportPatchesAug:
1900    """
1901    -export-patches-aug, -xpa: data augmentation for deep learning
1902    
1903    Syntax `-export-patches-aug <N> <sigma_angle>`
1904    
1905    This command must precede the `-export-patches (-xp)` command and instructs
1906    this command to not only sample patches along the image axes but to also
1907    sample **N** randomly rotated patches. Rotation is around a uniformly
1908    distributed axis with a rotation angle distributed normally with teh
1909    standard deviation **sigma_angle**, specified in degrees. This kind of
1910    sampling is useful for data augmentation for machine learning algorithms.
1911    
1912    c3d chan1.nii chan2.nii chan3.nii mask.nii -xpa 5 10 -xp samples.dat 4x4x4
1913    100.
1914    """
1915    export_patches_aug: str
1916    """-export-patches-aug, -xpa: data augmentation for deep learning
1917    
1918    Syntax `-export-patches-aug <N> <sigma_angle>`
1919    
1920    This command must precede the `-export-patches (-xp)` command and instructs
1921    this command to not only sample patches along the image axes but to also
1922    sample **N** randomly rotated patches. Rotation is around a uniformly
1923    distributed axis with a rotation angle distributed normally with teh
1924    standard deviation **sigma_angle**, specified in degrees. This kind of
1925    sampling is useful for data augmentation for machine learning algorithms.
1926    
1927    c3d chan1.nii chan2.nii chan3.nii mask.nii -xpa 5 10 -xp samples.dat 4x4x4
1928    100"""
1929    
1930    def run(
1931        self,
1932        execution: Execution,
1933    ) -> list[str]:
1934        """
1935        Build command line arguments. This method is called by the main command.
1936        
1937        Args:
1938            execution: The execution object.
1939        Returns:
1940            Command line arguments
1941        """
1942        cargs = []
1943        cargs.extend([
1944            "-export-patches-aug",
1945            self.export_patches_aug
1946        ])
1947        return cargs
1948
1949
1950@dataclasses.dataclass
1951class C3dExtrudeSeg:
1952    """
1953    No description found.
1954    """
1955    extrude_seg: str
1956    """No description found."""
1957    
1958    def run(
1959        self,
1960        execution: Execution,
1961    ) -> list[str]:
1962        """
1963        Build command line arguments. This method is called by the main command.
1964        
1965        Args:
1966            execution: The execution object.
1967        Returns:
1968            Command line arguments
1969        """
1970        cargs = []
1971        cargs.extend([
1972            "-extrude-seg",
1973            self.extrude_seg
1974        ])
1975        return cargs
1976
1977
1978@dataclasses.dataclass
1979class C3dFillBackgroundWithNoise:
1980    """
1981    No description found.
1982    """
1983    fill_background_with_noise: str
1984    """No description found."""
1985    
1986    def run(
1987        self,
1988        execution: Execution,
1989    ) -> list[str]:
1990        """
1991        Build command line arguments. This method is called by the main command.
1992        
1993        Args:
1994            execution: The execution object.
1995        Returns:
1996            Command line arguments
1997        """
1998        cargs = []
1999        cargs.extend([
2000            "-fill-background-with-noise",
2001            self.fill_background_with_noise
2002        ])
2003        return cargs
2004
2005
2006@dataclasses.dataclass
2007class C3dFft:
2008    """
2009    -fft: Fast Fourier transform
2010    
2011    Syntax `-fft`
2012    
2013    Computes the Fourier transform of a real-valued image at the end of the
2014    stack. The image is replaced by the real and imaginary components of the
2015    FFT. This command is only available if **convert3d** is compiled with the
2016    FFTW library support.
2017    
2018    c3d image.nii -fft -oo real.nii imag.nii.
2019    """
2020    fft: str
2021    """-fft: Fast Fourier transform
2022    
2023    Syntax `-fft`
2024    
2025    Computes the Fourier transform of a real-valued image at the end of the
2026    stack. The image is replaced by the real and imaginary components of the
2027    FFT. This command is only available if **convert3d** is compiled with the
2028    FFTW library support.
2029    
2030    c3d image.nii -fft -oo real.nii imag.nii"""
2031    
2032    def run(
2033        self,
2034        execution: Execution,
2035    ) -> list[str]:
2036        """
2037        Build command line arguments. This method is called by the main command.
2038        
2039        Args:
2040            execution: The execution object.
2041        Returns:
2042            Command line arguments
2043        """
2044        cargs = []
2045        cargs.extend([
2046            "-fft",
2047            self.fft
2048        ])
2049        return cargs
2050
2051
2052@dataclasses.dataclass
2053class C3dFlip:
2054    """
2055    -flip: Flip image around an axis
2056    
2057    Syntax: `-flip axes`
2058    
2059    Flips the image around specified axes. The parameter 'axes' may be any
2060    combination of characters 'x', 'y', and 'z'; the order does not matter.
2061    
2062    c3d input.img -flip xy -o output.img.
2063    """
2064    flip: str
2065    """-flip: Flip image around an axis
2066    
2067    Syntax: `-flip axes`
2068    
2069    Flips the image around specified axes. The parameter 'axes' may be any
2070    combination of characters 'x', 'y', and 'z'; the order does not matter.
2071    
2072    c3d input.img -flip xy -o output.img"""
2073    
2074    def run(
2075        self,
2076        execution: Execution,
2077    ) -> list[str]:
2078        """
2079        Build command line arguments. This method is called by the main command.
2080        
2081        Args:
2082            execution: The execution object.
2083        Returns:
2084            Command line arguments
2085        """
2086        cargs = []
2087        cargs.extend([
2088            "-flip",
2089            self.flip
2090        ])
2091        return cargs
2092
2093
2094@dataclasses.dataclass
2095class C3dFloor:
2096    """
2097    -floor: Round down image intensities
2098    
2099    Syntax: `-floor `
2100    
2101    Each image intensity is replaced by the largest integer smaller or equal to
2102    it.
2103    
2104    c3d input.img -floor -o output.img
2105    
2106    To round each intensity to the closest integer, use
2107    
2108    c3d input.img -shift 0.5 -floor.
2109    """
2110    floor: str
2111    """-floor: Round down image intensities
2112    
2113    Syntax: `-floor `
2114    
2115    Each image intensity is replaced by the largest integer smaller or equal to
2116    it.
2117    
2118    c3d input.img -floor -o output.img
2119    
2120    To round each intensity to the closest integer, use
2121    
2122    c3d input.img -shift 0.5 -floor"""
2123    
2124    def run(
2125        self,
2126        execution: Execution,
2127    ) -> list[str]:
2128        """
2129        Build command line arguments. This method is called by the main command.
2130        
2131        Args:
2132            execution: The execution object.
2133        Returns:
2134            Command line arguments
2135        """
2136        cargs = []
2137        cargs.extend([
2138            "-floor",
2139            self.floor
2140        ])
2141        return cargs
2142
2143
2144@dataclasses.dataclass
2145class C3dForeach:
2146    """
2147    -foreach, -endfor: Loop commands over all images on the stack
2148    
2149    Syntax: `-foreach commands-list -endfor`
2150    
2151    This command forces the commands between **-foreach** and **-endfor** to be
2152    applied to every image on the stack. The main use of this command is to
2153    automate processing of multiple datasets. For example,
2154    
2155    c3d epi*.nii -foreach -smooth 3mm -endfor -oo epism%03d.nii.
2156    """
2157    foreach: str
2158    """-foreach, -endfor: Loop commands over all images on the stack
2159    
2160    Syntax: `-foreach commands-list -endfor`
2161    
2162    This command forces the commands between **-foreach** and **-endfor** to be
2163    applied to every image on the stack. The main use of this command is to
2164    automate processing of multiple datasets. For example,
2165    
2166    c3d epi*.nii -foreach -smooth 3mm -endfor -oo epism%03d.nii"""
2167    
2168    def run(
2169        self,
2170        execution: Execution,
2171    ) -> list[str]:
2172        """
2173        Build command line arguments. This method is called by the main command.
2174        
2175        Args:
2176            execution: The execution object.
2177        Returns:
2178            Command line arguments
2179        """
2180        cargs = []
2181        cargs.extend([
2182            "-foreach",
2183            self.foreach
2184        ])
2185        return cargs
2186
2187
2188@dataclasses.dataclass
2189class C3dForeachComp:
2190    """
2191    -foreach-comp, -endfor: Loop commands over components of a multi-component
2192    image
2193    
2194    Syntax `-foreach-comp <N> commands-list -endfor`
2195    
2196    This command runs the list of commands separately for each component of a
2197    set of multi-component images loaded with -mcs. This makes it possible to
2198    perform component-wise operations on multi-component images. For example, it
2199    can be used to average several multi-component images. If the image stack
2200    contains images *x1* *y1* *z1* *x2* *y2* *z2*, then the operations will be
2201    run on *[x1,x2]*, *[y1,y2]*, *[z1,z2]*. For example, if multi_1.nii to
2202    multi_10.nii are three-component images, then the mean three-component image
2203    is given by
2204    
2205    c2d -mcs multi_*.nii -foreach-comp -mean -endfor -omc multi_mean.nii.
2206    """
2207    foreach_comp: str
2208    """-foreach-comp, -endfor: Loop commands over components of a
2209    multi-component image
2210    
2211    Syntax `-foreach-comp <N> commands-list -endfor`
2212    
2213    This command runs the list of commands separately for each component of a
2214    set of multi-component images loaded with -mcs. This makes it possible to
2215    perform component-wise operations on multi-component images. For example, it
2216    can be used to average several multi-component images. If the image stack
2217    contains images *x1* *y1* *z1* *x2* *y2* *z2*, then the operations will be
2218    run on *[x1,x2]*, *[y1,y2]*, *[z1,z2]*. For example, if multi_1.nii to
2219    multi_10.nii are three-component images, then the mean three-component image
2220    is given by
2221    
2222    c2d -mcs multi_*.nii -foreach-comp -mean -endfor -omc multi_mean.nii"""
2223    
2224    def run(
2225        self,
2226        execution: Execution,
2227    ) -> list[str]:
2228        """
2229        Build command line arguments. This method is called by the main command.
2230        
2231        Args:
2232            execution: The execution object.
2233        Returns:
2234            Command line arguments
2235        """
2236        cargs = []
2237        cargs.extend([
2238            "-foreach-comp",
2239            self.foreach_comp
2240        ])
2241        return cargs
2242
2243
2244@dataclasses.dataclass
2245class C3dGlm:
2246    """
2247    -glm: General linear model
2248    
2249    Syntax: `-glm design_matrix_file contrast_vector_file`
2250    
2251    Applies voxel-wise general linear model to a set of images. More precisely,
2252    the general linear model solves the following system: $Y = X \beta +
2253    \epsilon$, where Y are the observations (a list of n images, where each
2254    voxel is treated as an independent observation); X is the $n x k$ design
2255    matrix, where $k$ is the number of factors; $\beta$ is a set of $k$ unknown
2256    images (factors) and $\epsilon$ is the error term. The command will compute
2257    the $\beta$ images and return a weighted sum of them, where the weights are
2258    specified in the contrast vector. The design matrix and the contrast vector
2259    are passed in as files. The file format is just a space-separated list of
2260    numbers. For a good explanation of the general linear model, see [S. Kiebel
2261    and A. Holmes, General Linear Model, in Ashburner, Friston, Holmes eds.,
2262    *Human Brain Function, 2nd Edition*][6]. The example below computes the
2263    regression coefficient between a set of longitudinal images and subject's
2264    age:
2265    
2266    echo "1 67.00" > design_mat.txt
2267    echo "1 75.00" >> design_mat.txt
2268    echo "1 80.00" >> design_mat.txt
2269    echo "1 83.00" >> design_mat.txt
2270    echo "0 1" >> contrast_vec.txt
2271    c3d time1.img time2.img time3.img time4.img -glm design_mat.txt
2272    contrast_vec.txt -o regress.img.
2273    """
2274    glm: str
2275    """-glm: General linear model
2276    
2277    Syntax: `-glm design_matrix_file contrast_vector_file`
2278    
2279    Applies voxel-wise general linear model to a set of images. More precisely,
2280    the general linear model solves the following system: $Y = X \beta +
2281    \epsilon$, where Y are the observations (a list of n images, where each
2282    voxel is treated as an independent observation); X is the $n x k$ design
2283    matrix, where $k$ is the number of factors; $\beta$ is a set of $k$ unknown
2284    images (factors) and $\epsilon$ is the error term. The command will compute
2285    the $\beta$ images and return a weighted sum of them, where the weights are
2286    specified in the contrast vector. The design matrix and the contrast vector
2287    are passed in as files. The file format is just a space-separated list of
2288    numbers. For a good explanation of the general linear model, see [S. Kiebel
2289    and A. Holmes, General Linear Model, in Ashburner, Friston, Holmes eds.,
2290    *Human Brain Function, 2nd Edition*][6]. The example below computes the
2291    regression coefficient between a set of longitudinal images and subject's
2292    age:
2293    
2294    echo "1 67.00" > design_mat.txt
2295    echo "1 75.00" >> design_mat.txt
2296    echo "1 80.00" >> design_mat.txt
2297    echo "1 83.00" >> design_mat.txt
2298    echo "0 1" >> contrast_vec.txt
2299    c3d time1.img time2.img time3.img time4.img -glm design_mat.txt
2300    contrast_vec.txt -o regress.img"""
2301    
2302    def run(
2303        self,
2304        execution: Execution,
2305    ) -> list[str]:
2306        """
2307        Build command line arguments. This method is called by the main command.
2308        
2309        Args:
2310            execution: The execution object.
2311        Returns:
2312            Command line arguments
2313        """
2314        cargs = []
2315        cargs.extend([
2316            "-glm",
2317            self.glm
2318        ])
2319        return cargs
2320
2321
2322@dataclasses.dataclass
2323class C3dGradient:
2324    """
2325    -grad, -gradient: Image gradient
2326    
2327    Syntax `-grad`
2328    
2329    Computes the gradient of the image. Each component of the gradient is placed
2330    on the stack in order (x,y,z). The gradient is computed in physical RAS
2331    coordinates, taking into account image spacing and orientation. In other
2332    words, the gradient is the vector in physical space orthogonal to the
2333    isocontours of the image. No smoothing is performed, so it is a good idea to
2334    smooth the image first before computing the gradient.
2335    
2336    c3d myimage.nii -smooth 1.2vox -grad -oo grad_comp_%02d.nii.
2337    """
2338    gradient: str
2339    """-grad, -gradient: Image gradient
2340    
2341    Syntax `-grad`
2342    
2343    Computes the gradient of the image. Each component of the gradient is placed
2344    on the stack in order (x,y,z). The gradient is computed in physical RAS
2345    coordinates, taking into account image spacing and orientation. In other
2346    words, the gradient is the vector in physical space orthogonal to the
2347    isocontours of the image. No smoothing is performed, so it is a good idea to
2348    smooth the image first before computing the gradient.
2349    
2350    c3d myimage.nii -smooth 1.2vox -grad -oo grad_comp_%02d.nii"""
2351    
2352    def run(
2353        self,
2354        execution: Execution,
2355    ) -> list[str]:
2356        """
2357        Build command line arguments. This method is called by the main command.
2358        
2359        Args:
2360            execution: The execution object.
2361        Returns:
2362            Command line arguments
2363        """
2364        cargs = []
2365        cargs.extend([
2366            "-grad",
2367            self.gradient
2368        ])
2369        return cargs
2370
2371
2372@dataclasses.dataclass
2373class C3dHelp:
2374    """
2375    -hesseig, -hessian-eigenvalues: Compute eigenvalues of the Hessian matrix
2376    
2377    Syntax `-hesseig <scale>`
2378    
2379    Computes the Hessian matrix at every pixel of an image and the eigenvalues
2380    of the Hessian. Images of the eigenvalues (sorted by value) are placed on
2381    the stack. These images are useful as texture features. See also the
2382    '''-steig''' command. The scale determines the amount of Gaussian smoothing
2383    applied for computing the partial derivatives in the Hessian, and is in
2384    physical (mm) units.
2385    
2386    c3d myimage.nii -hesseig 2.0 -oo eig%02d.nii.gz.
2387    """
2388    v__help: str
2389    """-hesseig, -hessian-eigenvalues: Compute eigenvalues of the Hessian matrix
2390    
2391    Syntax `-hesseig <scale>`
2392    
2393    Computes the Hessian matrix at every pixel of an image and the eigenvalues
2394    of the Hessian. Images of the eigenvalues (sorted by value) are placed on
2395    the stack. These images are useful as texture features. See also the
2396    '''-steig''' command. The scale determines the amount of Gaussian smoothing
2397    applied for computing the partial derivatives in the Hessian, and is in
2398    physical (mm) units.
2399    
2400    c3d myimage.nii -hesseig 2.0 -oo eig%02d.nii.gz"""
2401    
2402    def run(
2403        self,
2404        execution: Execution,
2405    ) -> list[str]:
2406        """
2407        Build command line arguments. This method is called by the main command.
2408        
2409        Args:
2410            execution: The execution object.
2411        Returns:
2412            Command line arguments
2413        """
2414        cargs = []
2415        cargs.extend([
2416            "-h",
2417            self.v__help
2418        ])
2419        return cargs
2420
2421
2422@dataclasses.dataclass
2423class C3dHolefill:
2424    """
2425    -holefill: Fill holes in binary image
2426    
2427    Syntax: `-holefill intensity_value [0|1] `
2428    
2429    Apply the binary hole filling algorithm to a particular intensity value in
2430    the image. The input image is typically a binary image or a multi-label
2431    segmentation image. Holes (voxels not matching the specified intensity value
2432    that are completely contained by voxels matching this value) are filled. The
2433    second parameter specifies what type of topological connectivity is used to
2434    determine holes. The value 0 uses the default algorithm in ITK (face
2435    connectivity) and 1 uses the full connectivity variant (face, edge and
2436    vertex connectivity). For more details see the [ITK page for this
2437    algorithm][7].
2438    
2439    c3d segmentation.nii.gz -holefill 5 0 -type uchar -o filledlabel5.nii.gz.
2440    """
2441    holefill: str
2442    """-holefill: Fill holes in binary image
2443    
2444    Syntax: `-holefill intensity_value [0|1] `
2445    
2446    Apply the binary hole filling algorithm to a particular intensity value in
2447    the image. The input image is typically a binary image or a multi-label
2448    segmentation image. Holes (voxels not matching the specified intensity value
2449    that are completely contained by voxels matching this value) are filled. The
2450    second parameter specifies what type of topological connectivity is used to
2451    determine holes. The value 0 uses the default algorithm in ITK (face
2452    connectivity) and 1 uses the full connectivity variant (face, edge and
2453    vertex connectivity). For more details see the [ITK page for this
2454    algorithm][7].
2455    
2456    c3d segmentation.nii.gz -holefill 5 0 -type uchar -o filledlabel5.nii.gz"""
2457    
2458    def run(
2459        self,
2460        execution: Execution,
2461    ) -> list[str]:
2462        """
2463        Build command line arguments. This method is called by the main command.
2464        
2465        Args:
2466            execution: The execution object.
2467        Returns:
2468            Command line arguments
2469        """
2470        cargs = []
2471        cargs.extend([
2472            "-hf",
2473            self.holefill
2474        ])
2475        return cargs
2476
2477
2478@dataclasses.dataclass
2479class C3dHessianEigenvalues:
2480    """
2481    -hesseig, -hessian-eigenvalues: Compute eigenvalues of the Hessian matrix
2482    
2483    Syntax `-hesseig <scale>`
2484    
2485    Computes the Hessian matrix at every pixel of an image and the eigenvalues
2486    of the Hessian. Images of the eigenvalues (sorted by value) are placed on
2487    the stack. These images are useful as texture features. See also the
2488    '''-steig''' command. The scale determines the amount of Gaussian smoothing
2489    applied for computing the partial derivatives in the Hessian, and is in
2490    physical (mm) units.
2491    
2492    c3d myimage.nii -hesseig 2.0 -oo eig%02d.nii.gz.
2493    """
2494    hessian_eigenvalues: str
2495    """-hesseig, -hessian-eigenvalues: Compute eigenvalues of the Hessian matrix
2496    
2497    Syntax `-hesseig <scale>`
2498    
2499    Computes the Hessian matrix at every pixel of an image and the eigenvalues
2500    of the Hessian. Images of the eigenvalues (sorted by value) are placed on
2501    the stack. These images are useful as texture features. See also the
2502    '''-steig''' command. The scale determines the amount of Gaussian smoothing
2503    applied for computing the partial derivatives in the Hessian, and is in
2504    physical (mm) units.
2505    
2506    c3d myimage.nii -hesseig 2.0 -oo eig%02d.nii.gz"""
2507    
2508    def run(
2509        self,
2510        execution: Execution,
2511    ) -> list[str]:
2512        """
2513        Build command line arguments. This method is called by the main command.
2514        
2515        Args:
2516            execution: The execution object.
2517        Returns:
2518            Command line arguments
2519        """
2520        cargs = []
2521        cargs.extend([
2522            "-hesseig",
2523            self.hessian_eigenvalues
2524        ])
2525        return cargs
2526
2527
2528@dataclasses.dataclass
2529class C3dHessianObjectness:
2530    """
2531    -hessobj, -hessian-objectness: Hessian objectness filter
2532    
2533    Syntax: `-hessobj <dimension> <min_scale> <max_scale>`
2534    
2535    Also known as the Frangi vesselness filter, this filter can be used to
2536    highlight tube-like, sheet-like and blob-like objects in the image. For
2537    details, see documentation to the [corresponging ITK class][HTOMIF].
2538    
2539    Parameter `dimension` is an integer that determines the kind of features
2540    that are highlighed. Use 0 for blobs, 1 for tubes, 2 for pancakes, etc. The
2541    min and max scale parameters are floating point values, giving the scale of
2542    the features highlighted, in physical units. Typically, just one scale is
2543    used.
2544    
2545    # Detect vessel-like structures at scale 0.5mm
2546    c3d image.nii.gz -hessobj 1 0.5 0.5
2547    
2548    [HTOMIF]
2549    http://www.itk.org/Doxygen/html/classitk_1_1HessianToObjectnessMeasureImageFilter.html.
2550    """
2551    hessian_objectness: str
2552    """-hessobj, -hessian-objectness: Hessian objectness filter
2553    
2554    Syntax: `-hessobj <dimension> <min_scale> <max_scale>`
2555    
2556    Also known as the Frangi vesselness filter, this filter can be used to
2557    highlight tube-like, sheet-like and blob-like objects in the image. For
2558    details, see documentation to the [corresponging ITK class][HTOMIF].
2559    
2560    Parameter `dimension` is an integer that determines the kind of features
2561    that are highlighed. Use 0 for blobs, 1 for tubes, 2 for pancakes, etc. The
2562    min and max scale parameters are floating point values, giving the scale of
2563    the features highlighted, in physical units. Typically, just one scale is
2564    used.
2565    
2566    # Detect vessel-like structures at scale 0.5mm
2567    c3d image.nii.gz -hessobj 1 0.5 0.5
2568    
2569    [HTOMIF]
2570    http://www.itk.org/Doxygen/html/classitk_1_1HessianToObjectnessMeasureImageFilter.html"""
2571    
2572    def run(
2573        self,
2574        execution: Execution,
2575    ) -> list[str]:
2576        """
2577        Build command line arguments. This method is called by the main command.
2578        
2579        Args:
2580            execution: The execution object.
2581        Returns:
2582            Command line arguments
2583        """
2584        cargs = []
2585        cargs.extend([
2586            "-hessobj",
2587            self.hessian_objectness
2588        ])
2589        return cargs
2590
2591
2592@dataclasses.dataclass
2593class C3dHistogramMatch:
2594    """
2595    No description found.
2596    """
2597    histogram_match: str
2598    """No description found."""
2599    
2600    def run(
2601        self,
2602        execution: Execution,
2603    ) -> list[str]:
2604        """
2605        Build command line arguments. This method is called by the main command.
2606        
2607        Args:
2608            execution: The execution object.
2609        Returns:
2610            Command line arguments
2611        """
2612        cargs = []
2613        cargs.extend([
2614            "-histmatch",
2615            self.histogram_match
2616        ])
2617        return cargs
2618
2619
2620@dataclasses.dataclass
2621class C3dInfo:
2622    """
2623    -info: Display brief image information
2624    
2625    Syntax: `-info`
2626    
2627    Prints brief information about the last image on the stack. Does not affect
2628    the stack.
2629    
2630    c3d image.hdr -info
2631    
2632    Use with the **-foreach** command to get information on multiple images
2633    
2634    c3d images*.nii -foreach -info -endfor.
2635    """
2636    info: str
2637    """-info: Display brief image information
2638    
2639    Syntax: `-info`
2640    
2641    Prints brief information about the last image on the stack. Does not affect
2642    the stack.
2643    
2644    c3d image.hdr -info
2645    
2646    Use with the **-foreach** command to get information on multiple images
2647    
2648    c3d images*.nii -foreach -info -endfor"""
2649    
2650    def run(
2651        self,
2652        execution: Execution,
2653    ) -> list[str]:
2654        """
2655        Build command line arguments. This method is called by the main command.
2656        
2657        Args:
2658            execution: The execution object.
2659        Returns:
2660            Command line arguments
2661        """
2662        cargs = []
2663        cargs.extend([
2664            "-info",
2665            self.info
2666        ])
2667        return cargs
2668
2669
2670@dataclasses.dataclass
2671class C3dInfoFull:
2672    """
2673    -info-full: Display verbose image information
2674    
2675    Syntax: `-info-full`
2676    
2677    Prints extended information about the last image on the stack, such as the
2678    metadata dictionary. For example,
2679    
2680    c3d image.hdr -info-full.
2681    """
2682    info_full: str
2683    """-info-full: Display verbose image information
2684    
2685    Syntax: `-info-full`
2686    
2687    Prints extended information about the last image on the stack, such as the
2688    metadata dictionary. For example,
2689    
2690    c3d image.hdr -info-full"""
2691    
2692    def run(
2693        self,
2694        execution: Execution,
2695    ) -> list[str]:
2696        """
2697        Build command line arguments. This method is called by the main command.
2698        
2699        Args:
2700            execution: The execution object.
2701        Returns:
2702            Command line arguments
2703        """
2704        cargs = []
2705        cargs.extend([
2706            "-info-full",
2707            self.info_full
2708        ])
2709        return cargs
2710
2711
2712@dataclasses.dataclass
2713class C3dInsert:
2714    """
2715    -insert: Insert image anywhere in the stack
2716    
2717    Syntax: `-insert var pos`
2718    
2719    This command is similar to **-push**, but allows you to insert the image
2720    associated with 'var' at any position in the stack, counting from the end.
2721    When 'pos' is 0, the image is placed at the end of the stack (same as
2722    **-push**). When pos is one, the image is placed at the next-to-end
2723    position, and so on.
2724    """
2725    insert: str
2726    """-insert: Insert image anywhere in the stack
2727    
2728    Syntax: `-insert var pos`
2729    
2730    This command is similar to **-push**, but allows you to insert the image
2731    associated with 'var' at any position in the stack, counting from the end.
2732    When 'pos' is 0, the image is placed at the end of the stack (same as
2733    **-push**). When pos is one, the image is placed at the next-to-end
2734    position, and so on."""
2735    
2736    def run(
2737        self,
2738        execution: Execution,
2739    ) -> list[str]:
2740        """
2741        Build command line arguments. This method is called by the main command.
2742        
2743        Args:
2744            execution: The execution object.
2745        Returns:
2746            Command line arguments
2747        """
2748        cargs = []
2749        cargs.extend([
2750            "-insert",
2751            self.insert
2752        ])
2753        return cargs
2754
2755
2756@dataclasses.dataclass
2757class C3dInterpolation:
2758    """
2759    -interpolation: Set interpolation mode
2760    
2761    Syntax: `-interpolation <NearestNeighbor|Linear|Cubic|Sinc|Gaussian>
2762    [param]`
2763    
2764    Specifies the interpolation used with **-resample** and other commands.
2765    Default is **Linear**. Gaussian interpolation takes as the parameter the
2766    standard deviation of the Gaussian filter (e.g, 1mm). Gaussian interpolation
2767    is very similar in result to first smoothing an image with a Gaussian filter
2768    and then reslicing it with linear interpolation, but is more accurate and
2769    has less aliasing artifacts. It is also slower, and should only be used with
2770    small sigmas (a few voxels across).
2771    
2772    Shorthand 0 can be used for *NearestNeighbor*, 1 for *Linear* and 3 for
2773    *Cubic*. For example:
2774    
2775    c3d -int 3 test.nii -resample 200x200x200% -o cubic_supersample.nii.
2776    """
2777    interpolation: str
2778    """-interpolation: Set interpolation mode
2779    
2780    Syntax: `-interpolation <NearestNeighbor|Linear|Cubic|Sinc|Gaussian>
2781    [param]`
2782    
2783    Specifies the interpolation used with **-resample** and other commands.
2784    Default is **Linear**. Gaussian interpolation takes as the parameter the
2785    standard deviation of the Gaussian filter (e.g, 1mm). Gaussian interpolation
2786    is very similar in result to first smoothing an image with a Gaussian filter
2787    and then reslicing it with linear interpolation, but is more accurate and
2788    has less aliasing artifacts. It is also slower, and should only be used with
2789    small sigmas (a few voxels across).
2790    
2791    Shorthand 0 can be used for *NearestNeighbor*, 1 for *Linear* and 3 for
2792    *Cubic*. For example:
2793    
2794    c3d -int 3 test.nii -resample 200x200x200% -o cubic_supersample.nii"""
2795    
2796    def run(
2797        self,
2798        execution: Execution,
2799    ) -> list[str]:
2800        """
2801        Build command line arguments. This method is called by the main command.
2802        
2803        Args:
2804            execution: The execution object.
2805        Returns:
2806            Command line arguments
2807        """
2808        cargs = []
2809        cargs.extend([
2810            "-interpolation",
2811            self.interpolation
2812        ])
2813        return cargs
2814
2815
2816@dataclasses.dataclass
2817class C3dIterations:
2818    """
2819    No description found.
2820    """
2821    iterations: str
2822    """No description found."""
2823    
2824    def run(
2825        self,
2826        execution: Execution,
2827    ) -> list[str]:
2828        """
2829        Build command line arguments. This method is called by the main command.
2830        
2831        Args:
2832            execution: The execution object.
2833        Returns:
2834            Command line arguments
2835        """
2836        cargs = []
2837        cargs.extend([
2838            "-iterations",
2839            self.iterations
2840        ])
2841        return cargs
2842
2843
2844@dataclasses.dataclass
2845class C3dLabelOverlap:
2846    """
2847    No description found.
2848    """
2849    label_overlap: str
2850    """No description found."""
2851    
2852    def run(
2853        self,
2854        execution: Execution,
2855    ) -> list[str]:
2856        """
2857        Build command line arguments. This method is called by the main command.
2858        
2859        Args:
2860            execution: The execution object.
2861        Returns:
2862            Command line arguments
2863        """
2864        cargs = []
2865        cargs.extend([
2866            "-label-overlap",
2867            self.label_overlap
2868        ])
2869        return cargs
2870
2871
2872@dataclasses.dataclass
2873class C3dLabelStatistics:
2874    """
2875    -lstat, -label-statistics: Display segmentation volumes and intensity
2876    statistics
2877    
2878    Syntax: `-lstat`
2879    
2880    Given a grayscale image and a multilabel (or binary) image, this command
2881    computes the statistics for every label in the latter, including volumes,
2882    average grayscale intensity, etc. For instance, if image *mri.nii* is a
2883    medical image and *seg.nii* is a multilabel segmentation of the image with
2884    labels 0, 1 and 4, the following command can be used to print the statistics
2885    of the intensity of *mri.nii* for each of the labels
2886    
2887    c3d mri.nii seg.nii -lstat
2888    
2889    The output contains the mean, standard deviation, maximum intensity and
2890    minimum intensity for each label. If you just need volumes from a
2891    multi-label image, use **-dup** command as follows:
2892    
2893    c3d seg.nii -dup -lstat.
2894    """
2895    label_statistics: str
2896    """-lstat, -label-statistics: Display segmentation volumes and intensity
2897    statistics
2898    
2899    Syntax: `-lstat`
2900    
2901    Given a grayscale image and a multilabel (or binary) image, this command
2902    computes the statistics for every label in the latter, including volumes,
2903    average grayscale intensity, etc. For instance, if image *mri.nii* is a
2904    medical image and *seg.nii* is a multilabel segmentation of the image with
2905    labels 0, 1 and 4, the following command can be used to print the statistics
2906    of the intensity of *mri.nii* for each of the labels
2907    
2908    c3d mri.nii seg.nii -lstat
2909    
2910    The output contains the mean, standard deviation, maximum intensity and
2911    minimum intensity for each label. If you just need volumes from a
2912    multi-label image, use **-dup** command as follows:
2913    
2914    c3d seg.nii -dup -lstat"""
2915    
2916    def run(
2917        self,
2918        execution: Execution,
2919    ) -> list[str]:
2920        """
2921        Build command line arguments. This method is called by the main command.
2922        
2923        Args:
2924            execution: The execution object.
2925        Returns:
2926            Command line arguments
2927        """
2928        cargs = []
2929        cargs.extend([
2930            "-label-statistics",
2931            self.label_statistics
2932        ])
2933        return cargs
2934
2935
2936@dataclasses.dataclass
2937class C3dLandmarksToSpheres:
2938    """
2939    No description found.
2940    """
2941    landmarks_to_spheres: str
2942    """No description found."""
2943    
2944    def run(
2945        self,
2946        execution: Execution,
2947    ) -> list[str]:
2948        """
2949        Build command line arguments. This method is called by the main command.
2950        
2951        Args:
2952            execution: The execution object.
2953        Returns:
2954            Command line arguments
2955        """
2956        cargs = []
2957        cargs.extend([
2958            "-landmarks-to-spheres",
2959            self.landmarks_to_spheres
2960        ])
2961        return cargs
2962
2963
2964@dataclasses.dataclass
2965class C3dLaplacian:
2966    """
2967    -laplacian, -laplace: Laplacian filter
2968    
2969    Syntax: `-laplacian`
2970    
2971    Applies the Laplacian filter to the image. Used to detect ridges of
2972    intensity. Typically, used with the **-smooth** option to obtain the
2973    equivalent of convolving the image with the *Laplacian of the Gaussian
2974    (LoG)* kernel:
2975    
2976    c3d input.img -smooth 1.2vox -laplacian -o output.img.
2977    """
2978    laplacian: str
2979    """-laplacian, -laplace: Laplacian filter
2980    
2981    Syntax: `-laplacian`
2982    
2983    Applies the Laplacian filter to the image. Used to detect ridges of
2984    intensity. Typically, used with the **-smooth** option to obtain the
2985    equivalent of convolving the image with the *Laplacian of the Gaussian
2986    (LoG)* kernel:
2987    
2988    c3d input.img -smooth 1.2vox -laplacian -o output.img"""
2989    
2990    def run(
2991        self,
2992        execution: Execution,
2993    ) -> list[str]:
2994        """
2995        Build command line arguments. This method is called by the main command.
2996        
2997        Args:
2998            execution: The execution object.
2999        Returns:
3000            Command line arguments
3001        """
3002        cargs = []
3003        cargs.extend([
3004            "-laplacian",
3005            self.laplacian
3006        ])
3007        return cargs
3008
3009
3010@dataclasses.dataclass
3011class C3dLevelset:
3012    """
3013    -levelset: Level set segmentation
3014    
3015    Syntax: `-levelset n_iter `
3016    
3017    Perform level set segmentation for *n\_iter* iterations, like in ITK-SNAP.
3018    The last image on the stack is treated as the initialization image and the
3019    next-to-last image on the stack is the speed image. Both images should be in
3020    the range between -1 and 1. Here is how the signs of the different images
3021    are interpreted
3022    
3023    | | Speed Image | Initialization Image | Output Image |
3024    | -- | ------------- | -------------------- | ------------ |
3025    | +1 | Foreground | Outside | Outside |
3026    | -1 | Background | Inside | Inside |
3027    
3028    Here is an example where you have the speed and the initialization given:
3029    
3030    c3d speed.img initial.img -levelset-curvature 0.5 -levelset 100 -o seg.img
3031    
3032    Here is an example of segmenting the ventricles in an MRI image, where the
3033    ventricles and other CSF have intensity below 715. The image
3034    seg_bubbles.nii.gz in this example is a binary image of the initialization
3035    seeds (1 inside the seeds, 0 outside).
3036    
3037    c3d brain.nii.gz -erf 715 100 -scale -1 seg_bubbles.nii.gz \
3038    -replace 0 1 1 -1 -levelset-curvature 0.2 -levelset 500 \
3039    -thresh -inf 0 1 0 -o segmentation.nii.gz
3040    
3041    Another example of smoothing a binary image that is useful for cleaning up
3042    manual segmentations. Here the speed image is positive inside the binary
3043    object, and the initialization is negative inside the object. The command
3044    writes out both the level set image (whose 0-level set is the smoothed
3045    boundary of the binary object) and the smoothed binary object
3046    
3047    c3d binary.img -threshold 1 inf 1 -1 -binary.img 1 inf 1 -1 \
3048    -levelset-curvature 1.5 -levelset 100 -o levelset.img \
3049    -thresh -inf 0 1 0 -o smoothed_binary.img.
3050    """
3051    levelset: str
3052    """-levelset: Level set segmentation
3053    
3054    Syntax: `-levelset n_iter `
3055    
3056    Perform level set segmentation for *n\_iter* iterations, like in ITK-SNAP.
3057    The last image on the stack is treated as the initialization image and the
3058    next-to-last image on the stack is the speed image. Both images should be in
3059    the range between -1 and 1. Here is how the signs of the different images
3060    are interpreted
3061    
3062    | | Speed Image | Initialization Image | Output Image |
3063    | -- | ------------- | -------------------- | ------------ |
3064    | +1 | Foreground | Outside | Outside |
3065    | -1 | Background | Inside | Inside |
3066    
3067    Here is an example where you have the speed and the initialization given:
3068    
3069    c3d speed.img initial.img -levelset-curvature 0.5 -levelset 100 -o seg.img
3070    
3071    Here is an example of segmenting the ventricles in an MRI image, where the
3072    ventricles and other CSF have intensity below 715. The image
3073    seg_bubbles.nii.gz in this example is a binary image of the initialization
3074    seeds (1 inside the seeds, 0 outside).
3075    
3076    c3d brain.nii.gz -erf 715 100 -scale -1 seg_bubbles.nii.gz \
3077    -replace 0 1 1 -1 -levelset-curvature 0.2 -levelset 500 \
3078    -thresh -inf 0 1 0 -o segmentation.nii.gz
3079    
3080    Another example of smoothing a binary image that is useful for cleaning up
3081    manual segmentations. Here the speed image is positive inside the binary
3082    object, and the initialization is negative inside the object. The command
3083    writes out both the level set image (whose 0-level set is the smoothed
3084    boundary of the binary object) and the smoothed binary object
3085    
3086    c3d binary.img -threshold 1 inf 1 -1 -binary.img 1 inf 1 -1 \
3087    -levelset-curvature 1.5 -levelset 100 -o levelset.img \
3088    -thresh -inf 0 1 0 -o smoothed_binary.img"""
3089    
3090    def run(
3091        self,
3092        execution: Execution,
3093    ) -> list[str]:
3094        """
3095        Build command line arguments. This method is called by the main command.
3096        
3097        Args:
3098            execution: The execution object.
3099        Returns:
3100            Command line arguments
3101        """
3102        cargs = []
3103        cargs.extend([
3104            "-levelset",
3105            self.levelset
3106        ])
3107        return cargs
3108
3109
3110@dataclasses.dataclass
3111class C3dLevelsetCurvature:
3112    """
3113    No description found.
3114    """
3115    levelset_curvature: str
3116    """No description found."""
3117    
3118    def run(
3119        self,
3120        execution: Execution,
3121    ) -> list[str]:
3122        """
3123        Build command line arguments. This method is called by the main command.
3124        
3125        Args:
3126            execution: The execution object.
3127        Returns:
3128            Command line arguments
3129        """
3130        cargs = []
3131        cargs.extend([
3132            "-levelset-curvature",
3133            self.levelset_curvature
3134        ])
3135        return cargs
3136
3137
3138@dataclasses.dataclass
3139class C3dLevelsetAdvection:
3140    """
3141    No description found.
3142    """
3143    levelset_advection: str
3144    """No description found."""
3145    
3146    def run(
3147        self,
3148        execution: Execution,
3149    ) -> list[str]:
3150        """
3151        Build command line arguments. This method is called by the main command.
3152        
3153        Args:
3154            execution: The execution object.
3155        Returns:
3156            Command line arguments
3157        """
3158        cargs = []
3159        cargs.extend([
3160            "-levelset-advection",
3161            self.levelset_advection
3162        ])
3163        return cargs
3164
3165
3166@dataclasses.dataclass
3167class C3dLog:
3168    """
3169    -log, -ln: Voxelwise natural logarithm
3170    
3171    Syntax: `-log`
3172    
3173    Computes natural logarithm of each voxel in the last image on the stack.
3174    """
3175    log: str
3176    """-log, -ln: Voxelwise natural logarithm
3177    
3178    Syntax: `-log`
3179    
3180    Computes natural logarithm of each voxel in the last image on the stack."""
3181    
3182    def run(
3183        self,
3184        execution: Execution,
3185    ) -> list[str]:
3186        """
3187        Build command line arguments. This method is called by the main command.
3188        
3189        Args:
3190            execution: The execution object.
3191        Returns:
3192            Command line arguments
3193        """
3194        cargs = []
3195        cargs.extend([
3196            "-ln",
3197            self.log
3198        ])
3199        return cargs
3200
3201
3202@dataclasses.dataclass
3203class C3dLog10:
3204    """
3205    -log10: Voxelwise base 10 logarithm
3206    
3207    Syntax: `-log10`
3208    
3209    Computes base 10 logarithm of each voxel in the last image on the stack.
3210    """
3211    log10: str
3212    """-log10: Voxelwise base 10 logarithm
3213    
3214    Syntax: `-log10`
3215    
3216    Computes base 10 logarithm of each voxel in the last image on the stack."""
3217    
3218    def run(
3219        self,
3220        execution: Execution,
3221    ) -> list[str]:
3222        """
3223        Build command line arguments. This method is called by the main command.
3224        
3225        Args:
3226            execution: The execution object.
3227        Returns:
3228            Command line arguments
3229        """
3230        cargs = []
3231        cargs.extend([
3232            "-log10",
3233            self.log10
3234        ])
3235        return cargs
3236
3237
3238@dataclasses.dataclass
3239class C3dManual:
3240    """
3241    No description found.
3242    """
3243    manual: str
3244    """No description found."""
3245    
3246    def run(
3247        self,
3248        execution: Execution,
3249    ) -> list[str]:
3250        """
3251        Build command line arguments. This method is called by the main command.
3252        
3253        Args:
3254            execution: The execution object.
3255        Returns:
3256            Command line arguments
3257        """
3258        cargs = []
3259        cargs.extend([
3260            "-manual",
3261            self.manual
3262        ])
3263        return cargs
3264
3265
3266@dataclasses.dataclass
3267class C3dMatchBoundingBox:
3268    """
3269    -mbb, -match-bounding-box: Match bounding box of one image to another
3270    
3271    Syntax: `-mbb`
3272    
3273    Given two images on the stack (reference and target), sets the header of the
3274    target image so that the two images occupy the same physical space. The
3275    direction cosines of the target image are set to match the reference image.
3276    This command is related to '-copy-transform' but supports images of
3277    different size.
3278    
3279    c3d reference.nii target.nii -mbb -o out.nii.
3280    """
3281    match_bounding_box: str
3282    """-mbb, -match-bounding-box: Match bounding box of one image to another
3283    
3284    Syntax: `-mbb`
3285    
3286    Given two images on the stack (reference and target), sets the header of the
3287    target image so that the two images occupy the same physical space. The
3288    direction cosines of the target image are set to match the reference image.
3289    This command is related to '-copy-transform' but supports images of
3290    different size.
3291    
3292    c3d reference.nii target.nii -mbb -o out.nii"""
3293    
3294    def run(
3295        self,
3296        execution: Execution,
3297    ) -> list[str]:
3298        """
3299        Build command line arguments. This method is called by the main command.
3300        
3301        Args:
3302            execution: The execution object.
3303        Returns:
3304            Command line arguments
3305        """
3306        cargs = []
3307        cargs.extend([
3308            "-match-bounding-box",
3309            self.match_bounding_box
3310        ])
3311        return cargs
3312
3313
3314@dataclasses.dataclass
3315class C3dMaximum:
3316    """
3317    -max: Voxel-wise maximum of two images
3318    
3319    Syntax: `-max`
3320    
3321    Computes the voxel-wise maximum of two images. Can be used with the
3322    **-accum** command to compute maximum of all images.
3323    
3324    c3d i1.nii i2.nii -max -o max12.nii
3325    c3d i1.nii i2.nii i3.nii i4.nii -accum -max -endaccum -o max1234.nii.
3326    """
3327    maximum: str
3328    """-max: Voxel-wise maximum of two images
3329    
3330    Syntax: `-max`
3331    
3332    Computes the voxel-wise maximum of two images. Can be used with the
3333    **-accum** command to compute maximum of all images.
3334    
3335    c3d i1.nii i2.nii -max -o max12.nii
3336    c3d i1.nii i2.nii i3.nii i4.nii -accum -max -endaccum -o max1234.nii"""
3337    
3338    def run(
3339        self,
3340        execution: Execution,
3341    ) -> list[str]:
3342        """
3343        Build command line arguments. This method is called by the main command.
3344        
3345        Args:
3346            execution: The execution object.
3347        Returns:
3348            Command line arguments
3349        """
3350        cargs = []
3351        cargs.extend([
3352            "-maximum",
3353            self.maximum
3354        ])
3355        return cargs
3356
3357
3358@dataclasses.dataclass
3359class C3dMulticomponentSplit:
3360    """
3361    -mcs, -multicomponent-split: Enable splitting of multi-component images on
3362    read
3363    
3364    Syntax: `-mcs`
3365    
3366    Enable reading of multi-component images. By default, when a multi-component
3367    image is encountered, the components are combined into a single image.
3368    Setting the **-mcs** flag changes this behavior, and each of the components
3369    is loaded sequentially. See the section below on multi-component image
3370    support.
3371    
3372    $ c3d -mcs rgb.mha -foreach -probe 110x110x80mm -endfor
3373    Interpolated image value at 110 110 80 is 1
3374    Interpolated image value at 110 110 80 is 66
3375    Interpolated image value at 110 110 80 is 29
3376    
3377    $ c3d rgb.mha -foreach -probe 110x110x80mm -endfor
3378    Interpolated image value at 110 110 80 is 49.5198.
3379    """
3380    multicomponent_split: str
3381    """-mcs, -multicomponent-split: Enable splitting of multi-component images
3382    on read
3383    
3384    Syntax: `-mcs`
3385    
3386    Enable reading of multi-component images. By default, when a multi-component
3387    image is encountered, the components are combined into a single image.
3388    Setting the **-mcs** flag changes this behavior, and each of the components
3389    is loaded sequentially. See the section below on multi-component image
3390    support.
3391    
3392    $ c3d -mcs rgb.mha -foreach -probe 110x110x80mm -endfor
3393    Interpolated image value at 110 110 80 is 1
3394    Interpolated image value at 110 110 80 is 66
3395    Interpolated image value at 110 110 80 is 29
3396    
3397    $ c3d rgb.mha -foreach -probe 110x110x80mm -endfor
3398    Interpolated image value at 110 110 80 is 49.5198"""
3399    
3400    def run(
3401        self,
3402        execution: Execution,
3403    ) -> list[str]:
3404        """
3405        Build command line arguments. This method is called by the main command.
3406        
3407        Args:
3408            execution: The execution object.
3409        Returns:
3410            Command line arguments
3411        """
3412        cargs = []
3413        cargs.extend([
3414            "-mcs",
3415            self.multicomponent_split
3416        ])
3417        return cargs
3418
3419
3420@dataclasses.dataclass
3421class C3dMean:
3422    """
3423    -mean: Mean of all images on the stack
3424    
3425    Syntax: `-mean `
3426    
3427    Computes the mean of all the images on the stack. All images on the stack
3428    are replaced with the mean image.
3429    
3430    c3d image_*.nii -mean -o mean.nii.
3431    """
3432    mean: str
3433    """-mean: Mean of all images on the stack
3434    
3435    Syntax: `-mean `
3436    
3437    Computes the mean of all the images on the stack. All images on the stack
3438    are replaced with the mean image.
3439    
3440    c3d image_*.nii -mean -o mean.nii"""
3441    
3442    def run(
3443        self,
3444        execution: Execution,
3445    ) -> list[str]:
3446        """
3447        Build command line arguments. This method is called by the main command.
3448        
3449        Args:
3450            execution: The execution object.
3451        Returns:
3452            Command line arguments
3453        """
3454        cargs = []
3455        cargs.extend([
3456            "-mean",
3457            self.mean
3458        ])
3459        return cargs
3460
3461
3462@dataclasses.dataclass
3463class C3dMedianFilter:
3464    """
3465    -median, -median-filter: Median filter
3466    
3467    Syntax: `-median <radius_vector>`
3468    
3469    Applies the median filter: the intensity of each voxel is replaced by the
3470    median of the intensities in the neighborhood of size specified by the
3471    radius parameter. For example, the following code will apply the median
3472    filter with the 5x5x5 neighborhood.
3473    
3474    c3d in.nii -median 2x2x2 -o median.nii.
3475    """
3476    median_filter: str
3477    """-median, -median-filter: Median filter
3478    
3479    Syntax: `-median <radius_vector>`
3480    
3481    Applies the median filter: the intensity of each voxel is replaced by the
3482    median of the intensities in the neighborhood of size specified by the
3483    radius parameter. For example, the following code will apply the median
3484    filter with the 5x5x5 neighborhood.
3485    
3486    c3d in.nii -median 2x2x2 -o median.nii"""
3487    
3488    def run(
3489        self,
3490        execution: Execution,
3491    ) -> list[str]:
3492        """
3493        Build command line arguments. This method is called by the main command.
3494        
3495        Args:
3496            execution: The execution object.
3497        Returns:
3498            Command line arguments
3499        """
3500        cargs = []
3501        cargs.extend([
3502            "-median",
3503            self.median_filter
3504        ])
3505        return cargs
3506
3507
3508@dataclasses.dataclass
3509class C3dMerge:
3510    """
3511    -merge: Merge images from previous split command
3512    
3513    Syntax: `-merge`
3514    
3515    Works in conjunction with the **-split** command. Has similar behavior to
3516    **-vote**, except that label values are carried from the input to the
3517    **-split** command.
3518    """
3519    merge: str
3520    """-merge: Merge images from previous split command
3521    
3522    Syntax: `-merge`
3523    
3524    Works in conjunction with the **-split** command. Has similar behavior to
3525    **-vote**, except that label values are carried from the input to the
3526    **-split** command."""
3527    
3528    def run(
3529        self,
3530        execution: Execution,
3531    ) -> list[str]:
3532        """
3533        Build command line arguments. This method is called by the main command.
3534        
3535        Args:
3536            execution: The execution object.
3537        Returns:
3538            Command line arguments
3539        """
3540        cargs = []
3541        cargs.extend([
3542            "-merge",
3543            self.merge
3544        ])
3545        return cargs
3546
3547
3548@dataclasses.dataclass
3549class C3dMeanFilter:
3550    """
3551    -mf, -mean-filter: Mean filter
3552    
3553    Syntax: `-mf <radius_vector>`
3554    
3555    Applies the mean filter: the intensity of each voxel is replaced by the mean
3556    of the intensities in the neighborhood of size specified by the radius
3557    parameter. For example, the following code will apply the mean filter with
3558    the 5x5x5 neighborhood.
3559    
3560    c3d in.nii -mf 2x2x2 -o filtered.nii.
3561    """
3562    mean_filter: str
3563    """-mf, -mean-filter: Mean filter
3564    
3565    Syntax: `-mf <radius_vector>`
3566    
3567    Applies the mean filter: the intensity of each voxel is replaced by the mean
3568    of the intensities in the neighborhood of size specified by the radius
3569    parameter. For example, the following code will apply the mean filter with
3570    the 5x5x5 neighborhood.
3571    
3572    c3d in.nii -mf 2x2x2 -o filtered.nii"""
3573    
3574    def run(
3575        self,
3576        execution: Execution,
3577    ) -> list[str]:
3578        """
3579        Build command line arguments. This method is called by the main command.
3580        
3581        Args:
3582            execution: The execution object.
3583        Returns:
3584            Command line arguments
3585        """
3586        cargs = []
3587        cargs.extend([
3588            "-mf",
3589            self.mean_filter
3590        ])
3591        return cargs
3592
3593
3594@dataclasses.dataclass
3595class C3dMutualInfo:
3596    """
3597    -min: Voxel-wise minimum of two images
3598    
3599    Syntax: `-min`
3600    
3601    Computes the voxel-wise minimum of two images. Can be used with the
3602    **-accum** command to compute minimum of all images.
3603    
3604    c3d i1.nii i2.nii -min -o min12.nii
3605    c3d i1.nii i2.nii i3.nii i4.nii -accum -min -endaccum -o min1234.nii.
3606    """
3607    mutual_info: str
3608    """-min: Voxel-wise minimum of two images
3609    
3610    Syntax: `-min`
3611    
3612    Computes the voxel-wise minimum of two images. Can be used with the
3613    **-accum** command to compute minimum of all images.
3614    
3615    c3d i1.nii i2.nii -min -o min12.nii
3616    c3d i1.nii i2.nii i3.nii i4.nii -accum -min -endaccum -o min1234.nii"""
3617    
3618    def run(
3619        self,
3620        execution: Execution,
3621    ) -> list[str]:
3622        """
3623        Build command line arguments. This method is called by the main command.
3624        
3625        Args:
3626            execution: The execution object.
3627        Returns:
3628            Command line arguments
3629        """
3630        cargs = []
3631        cargs.extend([
3632            "-mi",
3633            self.mutual_info
3634        ])
3635        return cargs
3636
3637
3638@dataclasses.dataclass
3639class C3dMinimum:
3640    """
3641    -min: Voxel-wise minimum of two images
3642    
3643    Syntax: `-min`
3644    
3645    Computes the voxel-wise minimum of two images. Can be used with the
3646    **-accum** command to compute minimum of all images.
3647    
3648    c3d i1.nii i2.nii -min -o min12.nii
3649    c3d i1.nii i2.nii i3.nii i4.nii -accum -min -endaccum -o min1234.nii.
3650    """
3651    minimum: str
3652    """-min: Voxel-wise minimum of two images
3653    
3654    Syntax: `-min`
3655    
3656    Computes the voxel-wise minimum of two images. Can be used with the
3657    **-accum** command to compute minimum of all images.
3658    
3659    c3d i1.nii i2.nii -min -o min12.nii
3660    c3d i1.nii i2.nii i3.nii i4.nii -accum -min -endaccum -o min1234.nii"""
3661    
3662    def run(
3663        self,
3664        execution: Execution,
3665    ) -> list[str]:
3666        """
3667        Build command line arguments. This method is called by the main command.
3668        
3669        Args:
3670            execution: The execution object.
3671        Returns:
3672            Command line arguments
3673        """
3674        cargs = []
3675        cargs.extend([
3676            "-minimum",
3677            self.minimum
3678        ])
3679        return cargs
3680
3681
3682@dataclasses.dataclass
3683class C3dMixtureModel:
3684    """
3685    No description found.
3686    """
3687    mixture_model: str
3688    """No description found."""
3689    
3690    def run(
3691        self,
3692        execution: Execution,
3693    ) -> list[str]:
3694        """
3695        Build command line arguments. This method is called by the main command.
3696        
3697        Args:
3698            execution: The execution object.
3699        Returns:
3700            Command line arguments
3701        """
3702        cargs = []
3703        cargs.extend([
3704            "-mixture",
3705            self.mixture_model
3706        ])
3707        return cargs
3708
3709
3710@dataclasses.dataclass
3711class C3dMoments:
3712    """
3713    No description found.
3714    """
3715    moments: str
3716    """No description found."""
3717    
3718    def run(
3719        self,
3720        execution: Execution,
3721    ) -> list[str]:
3722        """
3723        Build command line arguments. This method is called by the main command.
3724        
3725        Args:
3726            execution: The execution object.
3727        Returns:
3728            Command line arguments
3729        """
3730        cargs = []
3731        cargs.extend([
3732            "-moments",
3733            self.moments
3734        ])
3735        return cargs
3736
3737
3738@dataclasses.dataclass
3739class C3dMattesMutualInfo:
3740    """
3741    No description found.
3742    """
3743    mattes_mutual_info: str
3744    """No description found."""
3745    
3746    def run(
3747        self,
3748        execution: Execution,
3749    ) -> list[str]:
3750        """
3751        Build command line arguments. This method is called by the main command.
3752        
3753        Args:
3754            execution: The execution object.
3755        Returns:
3756            Command line arguments
3757        """
3758        cargs = []
3759        cargs.extend([
3760            "-mmi",
3761            self.mattes_mutual_info
3762        ])
3763        return cargs
3764
3765
3766@dataclasses.dataclass
3767class C3dMeanSquare:
3768    """
3769    -msq, -mean-square: Compute mean square difference metric
3770    
3771    Syntax: `-msq [movtransform.mat] [reftransform.mat]`
3772    
3773    Compute the mean square difference metric between the last two images on the
3774    stack. If an optional *movtransform.mat* file is provided, the metric is
3775    computed by applying the transform to the moving image. If, in addition to
3776    *movtransform.mat*, the optional *reftransform.mat* file is also provided --
3777    the moving transform is applied to the moving image, the ref transform is
3778    applied to the reference image, and the metric is computed in an image space
3779    that is physically halfway between the reference and moving images. This may
3780    be useful for unbiased metric computation if the two transforms are inverse
3781    of each other as both images undergo similar amount of interpolation. The
3782    definitions of reference and moving images and the transform file format are
3783    similar to the **-reslice-matrix** command.
3784    
3785    # Compute metric between ref.nii and mov.nii
3786    c3d ref.nii mov.nii -msq
3787    
3788    # Compute metric between ref.nii and mov.nii after applying transform to
3789    mov.nii
3790    c3d ref.nii mov.nii -msq tmov.mat
3791    
3792    # Compute metric between ref.nii and mov.nii in a neutral space after
3793    applying transforms to both
3794    c3d ref.nii mov.nii -msq tmov.mat tref.mat.
3795    """
3796    mean_square: str
3797    """-msq, -mean-square: Compute mean square difference metric
3798    
3799    Syntax: `-msq [movtransform.mat] [reftransform.mat]`
3800    
3801    Compute the mean square difference metric between the last two images on the
3802    stack. If an optional *movtransform.mat* file is provided, the metric is
3803    computed by applying the transform to the moving image. If, in addition to
3804    *movtransform.mat*, the optional *reftransform.mat* file is also provided --
3805    the moving transform is applied to the moving image, the ref transform is
3806    applied to the reference image, and the metric is computed in an image space
3807    that is physically halfway between the reference and moving images. This may
3808    be useful for unbiased metric computation if the two transforms are inverse
3809    of each other as both images undergo similar amount of interpolation. The
3810    definitions of reference and moving images and the transform file format are
3811    similar to the **-reslice-matrix** command.
3812    
3813    # Compute metric between ref.nii and mov.nii
3814    c3d ref.nii mov.nii -msq
3815    
3816    # Compute metric between ref.nii and mov.nii after applying transform to
3817    mov.nii
3818    c3d ref.nii mov.nii -msq tmov.mat
3819    
3820    # Compute metric between ref.nii and mov.nii in a neutral space after
3821    applying transforms to both
3822    c3d ref.nii mov.nii -msq tmov.mat tref.mat"""
3823    
3824    def run(
3825        self,
3826        execution: Execution,
3827    ) -> list[str]:
3828        """
3829        Build command line arguments. This method is called by the main command.
3830        
3831        Args:
3832            execution: The execution object.
3833        Returns:
3834            Command line arguments
3835        """
3836        cargs = []
3837        cargs.extend([
3838            "-msq",
3839            self.mean_square
3840        ])
3841        return cargs
3842
3843
3844@dataclasses.dataclass
3845class C3dMultiply:
3846    """
3847    -multiply, -times: Multiply two images
3848    
3849    Syntax: `-multiply`
3850    
3851    Multiply two images voxel-by-voxel. The operation is applied to the last two
3852    images on the stack.
3853    
3854    # Compute x = a * b
3855    c3d a.img b.img -multiply -o x.img
3856    
3857    # Compute x = a * (b + c) using add and -multiply
3858    c3d a.img b.img c.img -multiply -add -o x.img
3859    
3860    Combine with the **-dup** command to compute voxelwise square of the image
3861    
3862    # Compute x = a^2
3863    c3d a.img -dup -multiply -o x.img.
3864    """
3865    multiply: str
3866    """-multiply, -times: Multiply two images
3867    
3868    Syntax: `-multiply`
3869    
3870    Multiply two images voxel-by-voxel. The operation is applied to the last two
3871    images on the stack.
3872    
3873    # Compute x = a * b
3874    c3d a.img b.img -multiply -o x.img
3875    
3876    # Compute x = a * (b + c) using add and -multiply
3877    c3d a.img b.img c.img -multiply -add -o x.img
3878    
3879    Combine with the **-dup** command to compute voxelwise square of the image
3880    
3881    # Compute x = a^2
3882    c3d a.img -dup -multiply -o x.img"""
3883    
3884    def run(
3885        self,
3886        execution: Execution,
3887    ) -> list[str]:
3888        """
3889        Build command line arguments. This method is called by the main command.
3890        
3891        Args:
3892            execution: The execution object.
3893        Returns:
3894            Command line arguments
3895        """
3896        cargs = []
3897        cargs.extend([
3898            "-multiply",
3899            self.multiply
3900        ])
3901        return cargs
3902
3903
3904@dataclasses.dataclass
3905class C3dNormalizedCrossCorrelation:
3906    """
3907    -ncc, -normalized-cross-correlation: Compute normalized cross-correlation
3908    image
3909    
3910    Syntax: `-ncc <radius_vector>`
3911    
3912    Computes normalized cross-correlation between two images that occupy the
3913    same physical space. Each voxel in the resulting image is the
3914    cross-correlation of patches of given radius surrounding the voxel in the
3915    two input images. This is different from **-ncor**, which computes a global
3916    cross-correlation metric value.
3917    """
3918    normalized_cross_correlation: str
3919    """-ncc, -normalized-cross-correlation: Compute normalized cross-correlation
3920    image
3921    
3922    Syntax: `-ncc <radius_vector>`
3923    
3924    Computes normalized cross-correlation between two images that occupy the
3925    same physical space. Each voxel in the resulting image is the
3926    cross-correlation of patches of given radius surrounding the voxel in the
3927    two input images. This is different from **-ncor**, which computes a global
3928    cross-correlation metric value."""
3929    
3930    def run(
3931        self,
3932        execution: Execution,
3933    ) -> list[str]:
3934        """
3935        Build command line arguments. This method is called by the main command.
3936        
3937        Args:
3938            execution: The execution object.
3939        Returns:
3940            Command line arguments
3941        """
3942        cargs = []
3943        cargs.extend([
3944            "-ncc",
3945            self.normalized_cross_correlation
3946        ])
3947        return cargs
3948
3949
3950@dataclasses.dataclass
3951class C3dNormalizedCorrelation:
3952    """
3953    -ncor, -normalized-correlation: Compute normalized correlation metric
3954    
3955    Syntax: `-ncor [movtransform.mat] [reftransform.mat]`
3956    
3957    : Compute the normalized correlation metric between the last two images on
3958    the stack. See documentation for **-msq***.
3959    """
3960    normalized_correlation: str
3961    """-ncor, -normalized-correlation: Compute normalized correlation metric
3962    
3963    Syntax: `-ncor [movtransform.mat] [reftransform.mat]`
3964    
3965    : Compute the normalized correlation metric between the last two images on
3966    the stack. See documentation for **-msq***."""
3967    
3968    def run(
3969        self,
3970        execution: Execution,
3971    ) -> list[str]:
3972        """
3973        Build command line arguments. This method is called by the main command.
3974        
3975        Args:
3976            execution: The execution object.
3977        Returns:
3978            Command line arguments
3979        """
3980        cargs = []
3981        cargs.extend([
3982            "-ncor",
3983            self.normalized_correlation
3984        ])
3985        return cargs
3986
3987
3988@dataclasses.dataclass
3989class C3dNormalizedMutualInfo:
3990    """
3991    -mmi, -mattes-mutual-info: Compute mutual informaiton metric
3992    
3993    Syntax: `-nmi [movtransform.mat] [reftransform.mat]`
3994    
3995    Compute the Mattes mutual information metric between the last two images on
3996    the stack. See documentation for **-msq**.
3997    """
3998    normalized_mutual_info: str
3999    """-mmi, -mattes-mutual-info: Compute mutual informaiton metric
4000    
4001    Syntax: `-nmi [movtransform.mat] [reftransform.mat]`
4002    
4003    Compute the Mattes mutual information metric between the last two images on
4004    the stack. See documentation for **-msq**."""
4005    
4006    def run(
4007        self,
4008        execution: Execution,
4009    ) -> list[str]:
4010        """
4011        Build command line arguments. This method is called by the main command.
4012        
4013        Args:
4014            execution: The execution object.
4015        Returns:
4016            Command line arguments
4017        """
4018        cargs = []
4019        cargs.extend([
4020            "-nmi",
4021            self.normalized_mutual_info
4022        ])
4023        return cargs
4024
4025
4026@dataclasses.dataclass
4027class C3dNoiseGaussian:
4028    """
4029    -noise-gaussian, -noise: Apply additive Gaussian noise
4030    
4031    Syntax: `-noise-gaussian <sigma>`
4032    
4033    Adds Gaussian noise to an image with zero mean and standard deviation sigma.
4034    Please see [Noise simulation article][15] by G. Lehmann for details.
4035    
4036    c3d image.nii -noise-gaussian 5 -o noisy.nii.
4037    """
4038    noise_gaussian: str
4039    """-noise-gaussian, -noise: Apply additive Gaussian noise
4040    
4041    Syntax: `-noise-gaussian <sigma>`
4042    
4043    Adds Gaussian noise to an image with zero mean and standard deviation sigma.
4044    Please see [Noise simulation article][15] by G. Lehmann for details.
4045    
4046    c3d image.nii -noise-gaussian 5 -o noisy.nii"""
4047    
4048    def run(
4049        self,
4050        execution: Execution,
4051    ) -> list[str]:
4052        """
4053        Build command line arguments. This method is called by the main command.
4054        
4055        Args:
4056            execution: The execution object.
4057        Returns:
4058            Command line arguments
4059        """
4060        cargs = []
4061        cargs.extend([
4062            "-noise-gaussian",
4063            self.noise_gaussian
4064        ])
4065        return cargs
4066
4067
4068@dataclasses.dataclass
4069class C3dNoisePoisson:
4070    """
4071    -noise-poisson: Apply Poisson noise
4072    Syntax: `-noise-poisson <scale>`
4073    
4074    Applies Poisson (shot) noise to an image with given scale. Please see [Noise
4075    simulation article][15] by G. Lehmann for details.
4076    
4077    c3d image.nii -noise-poisson 5 -o noisy.nii.
4078    """
4079    noise_poisson: str
4080    """-noise-poisson: Apply Poisson noise
4081    Syntax: `-noise-poisson <scale>`
4082    
4083    Applies Poisson (shot) noise to an image with given scale. Please see [Noise
4084    simulation article][15] by G. Lehmann for details.
4085    
4086    c3d image.nii -noise-poisson 5 -o noisy.nii"""
4087    
4088    def run(
4089        self,
4090        execution: Execution,
4091    ) -> list[str]:
4092        """
4093        Build command line arguments. This method is called by the main command.
4094        
4095        Args:
4096            execution: The execution object.
4097        Returns:
4098            Command line arguments
4099        """
4100        cargs = []
4101        cargs.extend([
4102            "-noise-poisson",
4103            self.noise_poisson
4104        ])
4105        return cargs
4106
4107
4108@dataclasses.dataclass
4109class C3dNoiseSpeckle:
4110    """
4111    -noise-speckle: Apply Poisson noise
4112    Syntax: `-noise-speckle <sigma>`
4113    
4114    Applies Speckle noise to an image with given standard deviation. Please see
4115    [Noise simulation article][15] by G. Lehmann for details.
4116    
4117    c3d image.nii -noise-speckle 5 -o noisy.nii.
4118    """
4119    noise_speckle: str
4120    """-noise-speckle: Apply Poisson noise
4121    Syntax: `-noise-speckle <sigma>`
4122    
4123    Applies Speckle noise to an image with given standard deviation. Please see
4124    [Noise simulation article][15] by G. Lehmann for details.
4125    
4126    c3d image.nii -noise-speckle 5 -o noisy.nii"""
4127    
4128    def run(
4129        self,
4130        execution: Execution,
4131    ) -> list[str]:
4132        """
4133        Build command line arguments. This method is called by the main command.
4134        
4135        Args:
4136            execution: The execution object.
4137        Returns:
4138            Command line arguments
4139        """
4140        cargs = []
4141        cargs.extend([
4142            "-noise-speckle",
4143            self.noise_speckle
4144        ])
4145        return cargs
4146
4147
4148@dataclasses.dataclass
4149class C3dNoiseSaltPepper:
4150    """
4151    -noise-salt-pepper: Apply salt and pepper noise
4152    Syntax: `-noise-salt-pepper <probability>`
4153    
4154    Applies salt and pepper noise to an image with given probability. Please see
4155    [Noise simulation article][15] by G. Lehmann for details.
4156    
4157    c3d image.nii -noise-salt-pepper 0.1 -o noisy.nii.
4158    """
4159    noise_salt_pepper: str
4160    """-noise-salt-pepper: Apply salt and pepper noise
4161    Syntax: `-noise-salt-pepper <probability>`
4162    
4163    Applies salt and pepper noise to an image with given probability. Please see
4164    [Noise simulation article][15] by G. Lehmann for details.
4165    
4166    c3d image.nii -noise-salt-pepper 0.1 -o noisy.nii"""
4167    
4168    def run(
4169        self,
4170        execution: Execution,
4171    ) -> list[str]:
4172        """
4173        Build command line arguments. This method is called by the main command.
4174        
4175        Args:
4176            execution: The execution object.
4177        Returns:
4178            Command line arguments
4179        """
4180        cargs = []
4181        cargs.extend([
4182            "-noise-salt-pepper",
4183            self.noise_salt_pepper
4184        ])
4185        return cargs
4186
4187
4188@dataclasses.dataclass
4189class C3dNoMulticomponentSplit:
4190    """
4191    -nomcs, -no-multicomponent-split: Disable splitting of multi-component
4192    images on read
4193    
4194    Syntax: `-nomcs`
4195    
4196    Used to reverse the effect of previous **-mcs** command.
4197    """
4198    no_multicomponent_split: str
4199    """-nomcs, -no-multicomponent-split: Disable splitting of multi-component
4200    images on read
4201    
4202    Syntax: `-nomcs`
4203    
4204    Used to reverse the effect of previous **-mcs** command."""
4205    
4206    def run(
4207        self,
4208        execution: Execution,
4209    ) -> list[str]:
4210        """
4211        Build command line arguments. This method is called by the main command.
4212        
4213        Args:
4214            execution: The execution object.
4215        Returns:
4216            Command line arguments
4217        """
4218        cargs = []
4219        cargs.extend([
4220            "-nomcs",
4221            self.no_multicomponent_split
4222        ])
4223        return cargs
4224
4225
4226@dataclasses.dataclass
4227class C3dNormalizeLocalWindow:
4228    """
4229    -nlw, -normalize-local-window: Standardize image intensity using local
4230    neighborhood
4231    
4232    Syntax: `-nlw <radius>`
4233    
4234    This command takes as inputs an image and a mask image. At each voxel, the
4235    mean of the local neighborhood is subtracted, and the result is divided by
4236    the standard deviation of the neighborhood. The mean and standard deviation
4237    are computed only over the masked region. You might also want to multiply by
4238    the mask.
4239    
4240    c3d gray.nii.gz mask.nii.gz -nlw 10x10x10 -o residual.nii.gz.
4241    """
4242    normalize_local_window: str
4243    """-nlw, -normalize-local-window: Standardize image intensity using local
4244    neighborhood
4245    
4246    Syntax: `-nlw <radius>`
4247    
4248    This command takes as inputs an image and a mask image. At each voxel, the
4249    mean of the local neighborhood is subtracted, and the result is divided by
4250    the standard deviation of the neighborhood. The mean and standard deviation
4251    are computed only over the masked region. You might also want to multiply by
4252    the mask.
4253    
4254    c3d gray.nii.gz mask.nii.gz -nlw 10x10x10 -o residual.nii.gz"""
4255    
4256    def run(
4257        self,
4258        execution: Execution,
4259    ) -> list[str]:
4260        """
4261        Build command line arguments. This method is called by the main command.
4262        
4263        Args:
4264            execution: The execution object.
4265        Returns:
4266            Command line arguments
4267        """
4268        cargs = []
4269        cargs.extend([
4270            "-nlw",
4271            self.normalize_local_window
4272        ])
4273        return cargs
4274
4275
4276@dataclasses.dataclass
4277class C3dNormpdf:
4278    """
4279    No description found.
4280    """
4281    normpdf: str
4282    """No description found."""
4283    
4284    def run(
4285        self,
4286        execution: Execution,
4287    ) -> list[str]:
4288        """
4289        Build command line arguments. This method is called by the main command.
4290        
4291        Args:
4292            execution: The execution object.
4293        Returns:
4294            Command line arguments
4295        """
4296        cargs = []
4297        cargs.extend([
4298            "-normpdf",
4299            self.normpdf
4300        ])
4301        return cargs
4302
4303
4304@dataclasses.dataclass
4305class C3dNoround:
4306    """
4307    -noround, -round: Floating point rounding behavior
4308    
4309    Syntax: `-noround` or `-round `
4310    
4311    By default, **convert3d** will round floating point values when converting
4312    to an integer, short or byte image. This command specifies that rounding
4313    should not be used. Rounding is used to avoid numerical errors stemming from
4314    the internal floating point representation.
4315    
4316    c3d image1.img -type short -noround image2.img.
4317    """
4318    noround: str
4319    """-noround, -round: Floating point rounding behavior
4320    
4321    Syntax: `-noround` or `-round `
4322    
4323    By default, **convert3d** will round floating point values when converting
4324    to an integer, short or byte image. This command specifies that rounding
4325    should not be used. Rounding is used to avoid numerical errors stemming from
4326    the internal floating point representation.
4327    
4328    c3d image1.img -type short -noround image2.img"""
4329    
4330    def run(
4331        self,
4332        execution: Execution,
4333    ) -> list[str]:
4334        """
4335        Build command line arguments. This method is called by the main command.
4336        
4337        Args:
4338            execution: The execution object.
4339        Returns:
4340            Command line arguments
4341        """
4342        cargs = []
4343        cargs.extend([
4344            "-noround",
4345            self.noround
4346        ])
4347        return cargs
4348
4349
4350@dataclasses.dataclass
4351class C3dNospm:
4352    """
4353    -spm, -nospm: SPM compatibility in Analyze output
4354    
4355    Syntax: `-spm` or `-nospm `
4356    
4357    These options specify whether use the SPM extension to the Analyze
4358    (.hdr,.img) format. When this option is on, the origin field stored by SPM
4359    in the Analyze header will be correctly interpreted. When saving analyze
4360    files, the origin will be set correctly. The default is equivalent to the
4361    **-nospm** option. Best to avoid this issue altogether by using NIFTI and
4362    SPM5 or later.
4363    
4364    c3d -spm in.hdr out.img.gz.
4365    """
4366    nospm: str
4367    """-spm, -nospm: SPM compatibility in Analyze output
4368    
4369    Syntax: `-spm` or `-nospm `
4370    
4371    These options specify whether use the SPM extension to the Analyze
4372    (.hdr,.img) format. When this option is on, the origin field stored by SPM
4373    in the Analyze header will be correctly interpreted. When saving analyze
4374    files, the origin will be set correctly. The default is equivalent to the
4375    **-nospm** option. Best to avoid this issue altogether by using NIFTI and
4376    SPM5 or later.
4377    
4378    c3d -spm in.hdr out.img.gz"""
4379    
4380    def run(
4381        self,
4382        execution: Execution,
4383    ) -> list[str]:
4384        """
4385        Build command line arguments. This method is called by the main command.
4386        
4387        Args:
4388            execution: The execution object.
4389        Returns:
4390            Command line arguments
4391        """
4392        cargs = []
4393        cargs.extend([
4394            "-nospm",
4395            self.nospm
4396        ])
4397        return cargs
4398
4399
4400class C3dOutputOutputs(typing.NamedTuple):
4401    """
4402    Output object returned when calling `C3dOutput(...)`.
4403    """
4404    root: OutputPathType
4405    """Output root folder. This is the root folder for all outputs."""
4406    output: OutputPathType
4407    """The output"""
4408
4409
4410@dataclasses.dataclass
4411class C3dOutput:
4412    """
4413    -o: Output (write) last image on the stack to image file
4414    
4415    Syntax: `-o filename`
4416    
4417    Write image, overriding an existing image. Without the **-o** option,
4418    **convert3d** will write an image only if it does not exist. The **-o**
4419    options protects input images from being accidentally deleted. Here we copy
4420    an image, changing format:
4421    
4422    c3d image1.mha -o image2.nii
4423    
4424    The **-o** option can also be used to save an intermediate image in the
4425    stack:
4426    
4427    c3d image1.img -threshold 1 10 1 0 -o thresh.img -resample 50% -o final.img.
4428    """
4429    output: str
4430    """-o: Output (write) last image on the stack to image file
4431    
4432    Syntax: `-o filename`
4433    
4434    Write image, overriding an existing image. Without the **-o** option,
4435    **convert3d** will write an image only if it does not exist. The **-o**
4436    options protects input images from being accidentally deleted. Here we copy
4437    an image, changing format:
4438    
4439    c3d image1.mha -o image2.nii
4440    
4441    The **-o** option can also be used to save an intermediate image in the
4442    stack:
4443    
4444    c3d image1.img -threshold 1 10 1 0 -o thresh.img -resample 50% -o
4445    final.img"""
4446    
4447    def run(
4448        self,
4449        execution: Execution,
4450    ) -> list[str]:
4451        """
4452        Build command line arguments. This method is called by the main command.
4453        
4454        Args:
4455            execution: The execution object.
4456        Returns:
4457            Command line arguments
4458        """
4459        cargs = []
4460        cargs.extend([
4461            "-o",
4462            self.output
4463        ])
4464        return cargs
4465    
4466    def outputs(
4467        self,
4468        execution: Execution,
4469    ) -> C3dOutputOutputs:
4470        """
4471        Collect output file paths.
4472        
4473        Args:
4474            execution: The execution object.
4475        Returns:
4476            NamedTuple of outputs (described in `C3dOutputOutputs`).
4477        """
4478        ret = C3dOutputOutputs(
4479            root=execution.output_file("."),
4480            output=execution.output_file(self.output),
4481        )
4482        return ret
4483
4484
4485@dataclasses.dataclass
4486class C3dOutputMulticomponent:
4487    """
4488    -omc, -output-multicomponent: Output multiple images to single file
4489    
4490    Syntax: `-omc [number] filename`
4491    
4492    Write multiple images on the **Convert3d** stack as a single multi-component
4493    image file. If the optional number *n* is specified, only the last *n*
4494    images on the stack will be used. Not all file formats support
4495    multi-component output. NIFTI is the safest bet.
4496    
4497    c3d red.nii green.nii blue.nii -omc rgb.mha
4498    
4499    For 2D images, this command can be used to generate color PNG files:
4500    
4501    c3d image.nii -slice z 50% -colormap jet -type uchar -omc colorslice.png.
4502    """
4503    output_multicomponent: str
4504    """-omc, -output-multicomponent: Output multiple images to single file
4505    
4506    Syntax: `-omc [number] filename`
4507    
4508    Write multiple images on the **Convert3d** stack as a single multi-component
4509    image file. If the optional number *n* is specified, only the last *n*
4510    images on the stack will be used. Not all file formats support
4511    multi-component output. NIFTI is the safest bet.
4512    
4513    c3d red.nii green.nii blue.nii -omc rgb.mha
4514    
4515    For 2D images, this command can be used to generate color PNG files:
4516    
4517    c3d image.nii -slice z 50% -colormap jet -type uchar -omc colorslice.png"""
4518    
4519    def run(
4520        self,
4521        execution: Execution,
4522    ) -> list[str]:
4523        """
4524        Build command line arguments. This method is called by the main command.
4525        
4526        Args:
4527            execution: The execution object.
4528        Returns:
4529            Command line arguments
4530        """
4531        cargs = []
4532        cargs.extend([
4533            "-omc",
4534            self.output_multicomponent
4535        ])
4536        return cargs
4537
4538
4539@dataclasses.dataclass
4540class C3dOutputMultipleMulticomponent:
4541    """
4542    -oomc: Output multiple multi-component images to multiple files
4543    
4544    Syntax: `-oomc n_comp image_list` or `-oomc n_comp image_spec`
4545    
4546    Write all images on the **convert3d** stack as multiple multi-component
4547    image files. The command is a mixture of the **-omc** and **-oo** commands.
4548    There must be a multiple of 'n_comp' images on the stack. Every consecutive
4549    'n_comp' images on the stack will be written to a separate multi-component
4550    image.
4551    
4552    ### Commands: Stack Manipulation and Flow Control
4553    
4554    These commands are used to manipulate the **convert3d** stack. The stack is
4555    a linear array of images. Every time an image is specified on the command
4556    line, it is loaded and placed at the end of the stack. Most operations take
4557    one image from the end of the stack, apply some operation to it, and place
4558    the result on the end of the stack. Certain commands like **-levelset** and
4559    **-reslice-matrix** take two images from the end of the stack as the input
4560    and replace them with a single output. Some other commands, like **-mean**
4561    and **-vote** take all images on the stack and replace them with a single
4562    output.
4563    
4564    Sometimes, for complex operations, it is useful to change the order of the
4565    images on the stack, to duplicate images, or to execute the same command
4566    multiple times. The stack manipulation and flow control commands allow you
4567    to complete complex tasks without saving intermediate images to the disk.
4568    """
4569    output_multiple_multicomponent: str
4570    """-oomc: Output multiple multi-component images to multiple files
4571    
4572    Syntax: `-oomc n_comp image_list` or `-oomc n_comp image_spec`
4573    
4574    Write all images on the **convert3d** stack as multiple multi-component
4575    image files. The command is a mixture of the **-omc** and **-oo** commands.
4576    There must be a multiple of 'n_comp' images on the stack. Every consecutive
4577    'n_comp' images on the stack will be written to a separate multi-component
4578    image.
4579    
4580    ### Commands: Stack Manipulation and Flow Control
4581    
4582    These commands are used to manipulate the **convert3d** stack. The stack is
4583    a linear array of images. Every time an image is specified on the command
4584    line, it is loaded and placed at the end of the stack. Most operations take
4585    one image from the end of the stack, apply some operation to it, and place
4586    the result on the end of the stack. Certain commands like **-levelset** and
4587    **-reslice-matrix** take two images from the end of the stack as the input
4588    and replace them with a single output. Some other commands, like **-mean**
4589    and **-vote** take all images on the stack and replace them with a single
4590    output.
4591    
4592    Sometimes, for complex operations, it is useful to change the order of the
4593    images on the stack, to duplicate images, or to execute the same command
4594    multiple times. The stack manipulation and flow control commands allow you
4595    to complete complex tasks without saving intermediate images to the disk."""
4596    
4597    def run(
4598        self,
4599        execution: Execution,
4600    ) -> list[str]:
4601        """
4602        Build command line arguments. This method is called by the main command.
4603        
4604        Args:
4605            execution: The execution object.
4606        Returns:
4607            Command line arguments
4608        """
4609        cargs = []
4610        cargs.extend([
4611            "-oomc",
4612            self.output_multiple_multicomponent
4613        ])
4614        return cargs
4615
4616
4617@dataclasses.dataclass
4618class C3dOrient:
4619    """
4620    -orient: Change image orientation
4621    
4622    Syntax: `-orient CODE`
4623    
4624    Set the orientation of the image using one of 48 canonical orientations. The
4625    orientation describes the mapping from the voxel coordinate system (i,j,k)
4626    to the physical coordinate system (x,y,z). In the voxel coordinate system, i
4627    runs along columns of voxels, j runs along rows of voxels, and k runs along
4628    slices of voxels. It is assumed (by the NIFTI convention) that the axes of
4629    the physical coordinate system run as follows: x from (L)eft to (R)ight, y
4630    from (P)osterior to (A)nterior, z from (I)nferior to (S)uperior.
4631    
4632    The CODE passed in is a three-letter code consisting of letters RLAPSI. Each
4633    letter describes the anatomical direction corresponding to the voxel
4634    coordinates (i,j,k). For example, code RAI means that i runs from Right to
4635    Left, j from Anterior to Posterior, and k from Inferior to Superior.
4636    
4637    c3d input.img -orient RAI -o output.img
4638    c3d input.img -orient SAL -o output.img
4639    
4640    This command has the same behavior as the 'Reorient Image' menu option in
4641    ITK-SNAP.
4642    """
4643    orient: str
4644    """-orient: Change image orientation
4645    
4646    Syntax: `-orient CODE`
4647    
4648    Set the orientation of the image using one of 48 canonical orientations. The
4649    orientation describes the mapping from the voxel coordinate system (i,j,k)
4650    to the physical coordinate system (x,y,z). In the voxel coordinate system, i
4651    runs along columns of voxels, j runs along rows of voxels, and k runs along
4652    slices of voxels. It is assumed (by the NIFTI convention) that the axes of
4653    the physical coordinate system run as follows: x from (L)eft to (R)ight, y
4654    from (P)osterior to (A)nterior, z from (I)nferior to (S)uperior.
4655    
4656    The CODE passed in is a three-letter code consisting of letters RLAPSI. Each
4657    letter describes the anatomical direction corresponding to the voxel
4658    coordinates (i,j,k). For example, code RAI means that i runs from Right to
4659    Left, j from Anterior to Posterior, and k from Inferior to Superior.
4660    
4661    c3d input.img -orient RAI -o output.img
4662    c3d input.img -orient SAL -o output.img
4663    
4664    This command has the same behavior as the 'Reorient Image' menu option in
4665    ITK-SNAP."""
4666    
4667    def run(
4668        self,
4669        execution: Execution,
4670    ) -> list[str]:
4671        """
4672        Build command line arguments. This method is called by the main command.
4673        
4674        Args:
4675            execution: The execution object.
4676        Returns:
4677            Command line arguments
4678        """
4679        cargs = []
4680        cargs.extend([
4681            "-orient",
4682            self.orient
4683        ])
4684        return cargs
4685
4686
4687@dataclasses.dataclass
4688class C3dOutputMultiple:
4689    """
4690    -oo: Output multiple images to multiple files
4691    
4692    Syntax: `-oo image_list` or `-oo image_spec`
4693    
4694    Write all images on the **convert3d** stack as multiple files. There are two
4695    ways to use this command. The first is to supply a list of file names,
4696    separated by spaces:
4697    
4698    c3d labelimage.nii -split -oo labelA.nii labelB.nii labelC.nii
4699    
4700    In the above example, the image at the end of the stack will be saved as
4701    *labelC.nii*, the image next to the end of the stack will be saved as
4702    *labelB.nii* and so on.
4703    
4704    The second way to use the **-oo** command is to supply a pattern for the
4705    output filenames. In this case, all the images on the stack will be written.
4706    The format for the pattern is the same as for the [C++ printf command][8].
4707    For example, the following command
4708    
4709    c3d labelimage.nii -split -oo label%02d.nii
4710    
4711    will generate images *label00.nii*, *label01.nii*, *label02.nii* and so on.
4712    The image at the end of the stack will have the highest number, and the
4713    image at the beginning of the stack will have number 00.
4714    """
4715    output_multiple: str
4716    """-oo: Output multiple images to multiple files
4717    
4718    Syntax: `-oo image_list` or `-oo image_spec`
4719    
4720    Write all images on the **convert3d** stack as multiple files. There are two
4721    ways to use this command. The first is to supply a list of file names,
4722    separated by spaces:
4723    
4724    c3d labelimage.nii -split -oo labelA.nii labelB.nii labelC.nii
4725    
4726    In the above example, the image at the end of the stack will be saved as
4727    *labelC.nii*, the image next to the end of the stack will be saved as
4728    *labelB.nii* and so on.
4729    
4730    The second way to use the **-oo** command is to supply a pattern for the
4731    output filenames. In this case, all the images on the stack will be written.
4732    The format for the pattern is the same as for the [C++ printf command][8].
4733    For example, the following command
4734    
4735    c3d labelimage.nii -split -oo label%02d.nii
4736    
4737    will generate images *label00.nii*, *label01.nii*, *label02.nii* and so on.
4738    The image at the end of the stack will have the highest number, and the
4739    image at the beginning of the stack will have number 00."""
4740    
4741    def run(
4742        self,
4743        execution: Execution,
4744    ) -> list[str]:
4745        """
4746        Build command line arguments. This method is called by the main command.
4747        
4748        Args:
4749            execution: The execution object.
4750        Returns:
4751            Command line arguments
4752        """
4753        cargs = []
4754        cargs.extend([
4755            "-oo",
4756            self.output_multiple
4757        ])
4758        return cargs
4759
4760
4761@dataclasses.dataclass
4762class C3dOrient_:
4763    """
4764    -orient: Change image orientation
4765    
4766    Syntax: `-orient CODE`
4767    
4768    Set the orientation of the image using one of 48 canonical orientations. The
4769    orientation describes the mapping from the voxel coordinate system (i,j,k)
4770    to the physical coordinate system (x,y,z). In the voxel coordinate system, i
4771    runs along columns of voxels, j runs along rows of voxels, and k runs along
4772    slices of voxels. It is assumed (by the NIFTI convention) that the axes of
4773    the physical coordinate system run as follows: x from (L)eft to (R)ight, y
4774    from (P)osterior to (A)nterior, z from (I)nferior to (S)uperior.
4775    
4776    The CODE passed in is a three-letter code consisting of letters RLAPSI. Each
4777    letter describes the anatomical direction corresponding to the voxel
4778    coordinates (i,j,k). For example, code RAI means that i runs from Right to
4779    Left, j from Anterior to Posterior, and k from Inferior to Superior.
4780    
4781    c3d input.img -orient RAI -o output.img
4782    c3d input.img -orient SAL -o output.img
4783    
4784    This command has the same behavior as the 'Reorient Image' menu option in
4785    ITK-SNAP.
4786    """
4787    orient: str
4788    """-orient: Change image orientation
4789    
4790    Syntax: `-orient CODE`
4791    
4792    Set the orientation of the image using one of 48 canonical orientations. The
4793    orientation describes the mapping from the voxel coordinate system (i,j,k)
4794    to the physical coordinate system (x,y,z). In the voxel coordinate system, i
4795    runs along columns of voxels, j runs along rows of voxels, and k runs along
4796    slices of voxels. It is assumed (by the NIFTI convention) that the axes of
4797    the physical coordinate system run as follows: x from (L)eft to (R)ight, y
4798    from (P)osterior to (A)nterior, z from (I)nferior to (S)uperior.
4799    
4800    The CODE passed in is a three-letter code consisting of letters RLAPSI. Each
4801    letter describes the anatomical direction corresponding to the voxel
4802    coordinates (i,j,k). For example, code RAI means that i runs from Right to
4803    Left, j from Anterior to Posterior, and k from Inferior to Superior.
4804    
4805    c3d input.img -orient RAI -o output.img
4806    c3d input.img -orient SAL -o output.img
4807    
4808    This command has the same behavior as the 'Reorient Image' menu option in
4809    ITK-SNAP."""
4810    
4811    def run(
4812        self,
4813        execution: Execution,
4814    ) -> list[str]:
4815        """
4816        Build command line arguments. This method is called by the main command.
4817        
4818        Args:
4819            execution: The execution object.
4820        Returns:
4821            Command line arguments
4822        """
4823        cargs = []
4824        cargs.extend([
4825            "-orient",
4826            self.orient
4827        ])
4828        return cargs
4829
4830
4831@dataclasses.dataclass
4832class C3dOrigin:
4833    """
4834    -origin: Set image origin
4835    
4836    Syntax: `-origin vector `
4837    
4838    Set the origin of the image. The origin is the world coordinate (in NIfTI
4839    coordinate space) of the center of the voxel (0,0,0) in the image. The
4840    origin should be specified in millimeters.
4841    
4842    c3d input.img -origin 100x100x100mm -o output.img.
4843    """
4844    origin: str
4845    """-origin: Set image origin
4846    
4847    Syntax: `-origin vector `
4848    
4849    Set the origin of the image. The origin is the world coordinate (in NIfTI
4850    coordinate space) of the center of the voxel (0,0,0) in the image. The
4851    origin should be specified in millimeters.
4852    
4853    c3d input.img -origin 100x100x100mm -o output.img"""
4854    
4855    def run(
4856        self,
4857        execution: Execution,
4858    ) -> list[str]:
4859        """
4860        Build command line arguments. This method is called by the main command.
4861        
4862        Args:
4863            execution: The execution object.
4864        Returns:
4865            Command line arguments
4866        """
4867        cargs = []
4868        cargs.extend([
4869            "-origin",
4870            self.origin
4871        ])
4872        return cargs
4873
4874
4875@dataclasses.dataclass
4876class C3dOriginVoxel:
4877    """
4878    -origin-voxel: Assign image origin to a voxel
4879    
4880    Syntax: `-origin-voxel vector `
4881    
4882    Set the origin of the image by specifying the voxel coordinates of the
4883    center of the patient (RAS) coordinate system. The vector should be
4884    specified in voxel units.
4885    
4886    c3d input.img -origin-voxel 60x70x35 -o output.img
4887    c3d input.img -origin-voxel 50% -o output.img # image centered around
4888    origin.
4889    """
4890    origin_voxel: str
4891    """-origin-voxel: Assign image origin to a voxel
4892    
4893    Syntax: `-origin-voxel vector `
4894    
4895    Set the origin of the image by specifying the voxel coordinates of the
4896    center of the patient (RAS) coordinate system. The vector should be
4897    specified in voxel units.
4898    
4899    c3d input.img -origin-voxel 60x70x35 -o output.img
4900    c3d input.img -origin-voxel 50% -o output.img # image centered around
4901    origin"""
4902    
4903    def run(
4904        self,
4905        execution: Execution,
4906    ) -> list[str]:
4907        """
4908        Build command line arguments. This method is called by the main command.
4909        
4910        Args:
4911            execution: The execution object.
4912        Returns:
4913            Command line arguments
4914        """
4915        cargs = []
4916        cargs.extend([
4917            "-origin-voxel",
4918            self.origin_voxel
4919        ])
4920        return cargs
4921
4922
4923@dataclasses.dataclass
4924class C3dOriginVoxelCoord:
4925    """
4926    -origin-voxel-coord: Set coordinate of specified voxel
4927    
4928    Syntax: `-origin-voxel-coord: <index> <vector>`
4929    
4930    This command updates the origin of the image such that the specifed voxel
4931    has the specified coordinate. For example, you can use the command to set
4932    the world coordinate (in NIFTI coordinate space) of the center voxel of the
4933    image, as follows:
4934    
4935    c3d input.nii -origin-voxel-coord: 50% 10x10x5mm -o output.nii.
4936    """
4937    origin_voxel_coord: str
4938    """-origin-voxel-coord: Set coordinate of specified voxel
4939    
4940    Syntax: `-origin-voxel-coord: <index> <vector>`
4941    
4942    This command updates the origin of the image such that the specifed voxel
4943    has the specified coordinate. For example, you can use the command to set
4944    the world coordinate (in NIFTI coordinate space) of the center voxel of the
4945    image, as follows:
4946    
4947    c3d input.nii -origin-voxel-coord: 50% 10x10x5mm -o output.nii"""
4948    
4949    def run(
4950        self,
4951        execution: Execution,
4952    ) -> list[str]:
4953        """
4954        Build command line arguments. This method is called by the main command.
4955        
4956        Args:
4957            execution: The execution object.
4958        Returns:
4959            Command line arguments
4960        """
4961        cargs = []
4962        cargs.extend([
4963            "-origin-voxel-coord",
4964            self.origin_voxel_coord
4965        ])
4966        return cargs
4967
4968
4969@dataclasses.dataclass
4970class C3dOverlap:
4971    """
4972    -overlap: Compute relative overlap between binary images
4973    
4974    Syntax: `-overlap Z`
4975    
4976    Compute relative overlap between labels in the last two images on the stack.
4977    Overlap is computed for a given label **Z**, i.e., the number of voxels that
4978    are equal to **Z** in both images is computed and divided by either the
4979    average number of voxels equal to **Z** in both images (to get Dice
4980    coefficient) or by the size of the region where at least one of the images
4981    is equal to **Z** (Jaccard coefficient).
4982    
4983    The command below computes overlap for label 255.
4984    
4985    c3d -verbose seg1.img seg2.img -overlap 255
4986    
4987    The output of the command is in the following terse format, with the last
4988    two values giving Dice and Jaccard coefficients, respectively.
4989    
4990    OVL: 1, 2383, 2474, 1807, 0.744081, 0.592459
4991    
4992    Use the flag **-verbose** to get full information.
4993    
4994    Matching voxels in first image: 2383
4995    Matching voxels in second image: 2474
4996    Size of overlap region: 1807
4997    Dice similarity coefficient: 0.744081
4998    Intersection / ratio: 0.592459
4999    
5000    This command does not alter the stack.
5001    """
5002    overlap: str
5003    """-overlap: Compute relative overlap between binary images
5004    
5005    Syntax: `-overlap Z`
5006    
5007    Compute relative overlap between labels in the last two images on the stack.
5008    Overlap is computed for a given label **Z**, i.e., the number of voxels that
5009    are equal to **Z** in both images is computed and divided by either the
5010    average number of voxels equal to **Z** in both images (to get Dice
5011    coefficient) or by the size of the region where at least one of the images
5012    is equal to **Z** (Jaccard coefficient).
5013    
5014    The command below computes overlap for label 255.
5015    
5016    c3d -verbose seg1.img seg2.img -overlap 255
5017    
5018    The output of the command is in the following terse format, with the last
5019    two values giving Dice and Jaccard coefficients, respectively.
5020    
5021    OVL: 1, 2383, 2474, 1807, 0.744081, 0.592459
5022    
5023    Use the flag **-verbose** to get full information.
5024    
5025    Matching voxels in first image: 2383
5026    Matching voxels in second image: 2474
5027    Size of overlap region: 1807
5028    Dice similarity coefficient: 0.744081
5029    Intersection / ratio: 0.592459
5030    
5031    This command does not alter the stack."""
5032    
5033    def run(
5034        self,
5035        execution: Execution,
5036    ) -> list[str]:
5037        """
5038        Build command line arguments. This method is called by the main command.
5039        
5040        Args:
5041            execution: The execution object.
5042        Returns:
5043            Command line arguments
5044        """
5045        cargs = []
5046        cargs.extend([
5047            "-overlap",
5048            self.overlap
5049        ])
5050        return cargs
5051
5052
5053@dataclasses.dataclass
5054class C3dOverlayLabelImage:
5055    """
5056    -oli, -overlay-label-image: Overlay segmentation image on grayscale image
5057    
5058    Syntax: `-oli lookup_table_file opacity`
5059    
5060    This command takes a grayscale image and a label image (i.e. image with a
5061    set of discrete values) and produces red, green and blue components of a
5062    color image. The resulting color image is an overlay of the labels over the
5063    grey image. The first parameter (*lookup\_table*) is a text file with
5064    entries in the format
5065    
5066    label_value red green blue alpha
5067    
5068    Alpha values must be between 0 and 1. Red, green and blue values should be
5069    on the same order as the intensity of the grey image (typically 0-255). The
5070    text file is compatible with ITK-SNAP and can be generated using the
5071    ITK-SNAP `Segmentation->Save Label Descriptions` command. The second
5072    parameter (*opacity*) is between 0 and 1 and sets the overall opacity of the
5073    overlay. The output of this command is similar to the way ITK-SNAP presents
5074    segmentation data on top of grayscale images.
5075    
5076    c3d gray.nii.gz -stretch 2% 98% 0 255 -clip 0 255 seg.nii.gz -oli labels.txt
5077    0.5 -omc rgb.nii.gz
5078    
5079    Note: this command does not interpolate between entries in the lookup table.
5080    It should not be used for images with a continuous intensity spectrum.
5081    
5082    Here is a more complex example, used to visualize a segmentation result. We
5083    do a few things in this command: trim grayscale and segmentation images to
5084    an ROI around the object of interest; map intensity range of the grayscale
5085    image to 0-255; extract slices through the middle of the cropped images;
5086    overlay segmentation on the grayscale image; and save as a color PNG file.
5087    
5088    c3d seg.nii.gz -trim 20x20x0vox -as S gray.nii.gz -stretch 2% 98% 0 255
5089    -clip 0 255 \\
5090    -reslice-identity -push S -foreach -slice z 50% -flip xy -endfor \\
5091    -oli labels.txt 0.5 -type uchar -omc ovl.png.
5092    """
5093    overlay_label_image: str
5094    """-oli, -overlay-label-image: Overlay segmentation image on grayscale image
5095    
5096    Syntax: `-oli lookup_table_file opacity`
5097    
5098    This command takes a grayscale image and a label image (i.e. image with a
5099    set of discrete values) and produces red, green and blue components of a
5100    color image. The resulting color image is an overlay of the labels over the
5101    grey image. The first parameter (*lookup\_table*) is a text file with
5102    entries in the format
5103    
5104    label_value red green blue alpha
5105    
5106    Alpha values must be between 0 and 1. Red, green and blue values should be
5107    on the same order as the intensity of the grey image (typically 0-255). The
5108    text file is compatible with ITK-SNAP and can be generated using the
5109    ITK-SNAP `Segmentation->Save Label Descriptions` command. The second
5110    parameter (*opacity*) is between 0 and 1 and sets the overall opacity of the
5111    overlay. The output of this command is similar to the way ITK-SNAP presents
5112    segmentation data on top of grayscale images.
5113    
5114    c3d gray.nii.gz -stretch 2% 98% 0 255 -clip 0 255 seg.nii.gz -oli labels.txt
5115    0.5 -omc rgb.nii.gz
5116    
5117    Note: this command does not interpolate between entries in the lookup table.
5118    It should not be used for images with a continuous intensity spectrum.
5119    
5120    Here is a more complex example, used to visualize a segmentation result. We
5121    do a few things in this command: trim grayscale and segmentation images to
5122    an ROI around the object of interest; map intensity range of the grayscale
5123    image to 0-255; extract slices through the middle of the cropped images;
5124    overlay segmentation on the grayscale image; and save as a color PNG file.
5125    
5126    c3d seg.nii.gz -trim 20x20x0vox -as S gray.nii.gz -stretch 2% 98% 0 255
5127    -clip 0 255 \\
5128    -reslice-identity -push S -foreach -slice z 50% -flip xy -endfor \\
5129    -oli labels.txt 0.5 -type uchar -omc ovl.png"""
5130    
5131    def run(
5132        self,
5133        execution: Execution,
5134    ) -> list[str]:
5135        """
5136        Build command line arguments. This method is called by the main command.
5137        
5138        Args:
5139            execution: The execution object.
5140        Returns:
5141            Command line arguments
5142        """
5143        cargs = []
5144        cargs.extend([
5145            "-overlay-label-image",
5146            self.overlay_label_image
5147        ])
5148        return cargs
5149
5150
5151@dataclasses.dataclass
5152class C3dPad:
5153    """
5154    -pad: Pad image with constant value
5155    
5156    Syntax: `-pad <padlower> <padupper> <value> `
5157    
5158    Pads the image by a given percentage or number of voxels. The *padlower*
5159    dimension pads along the zero faces of the image, and the *padupper*
5160    dimension pads along the upper faces of the image. For example to add 1
5161    voxel to the left side of an image, do
5162    
5163    c3d img1.nii -pad 1x0x0vox 0x0x0vox 0 -o padded.nii
5164    
5165    while
5166    
5167    c3d img1.nii -pad 2x2x4vox 0% 0 -o padded.nii
5168    
5169    adds two voxels padding to the left and posterior sides, and four slices to
5170    the bottom of the image. Note that the first argument changes the location
5171    of voxel (0,0,0) and thus the origin of the output image will be changed to
5172    maintain anatomical alignment between the padded and original images.
5173    
5174    Normally you will want to pad with zeros, but you can pad with any constant
5175    value, eg :
5176    
5177    c3d img1.nii -pad 10% 10% 1 -o padded.nii
5178    
5179    Adds 10% to all sides of the image, and fills the new voxels with the value
5180    1.
5181    """
5182    pad: str
5183    """-pad: Pad image with constant value
5184    
5185    Syntax: `-pad <padlower> <padupper> <value> `
5186    
5187    Pads the image by a given percentage or number of voxels. The *padlower*
5188    dimension pads along the zero faces of the image, and the *padupper*
5189    dimension pads along the upper faces of the image. For example to add 1
5190    voxel to the left side of an image, do
5191    
5192    c3d img1.nii -pad 1x0x0vox 0x0x0vox 0 -o padded.nii
5193    
5194    while
5195    
5196    c3d img1.nii -pad 2x2x4vox 0% 0 -o padded.nii
5197    
5198    adds two voxels padding to the left and posterior sides, and four slices to
5199    the bottom of the image. Note that the first argument changes the location
5200    of voxel (0,0,0) and thus the origin of the output image will be changed to
5201    maintain anatomical alignment between the padded and original images.
5202    
5203    Normally you will want to pad with zeros, but you can pad with any constant
5204    value, eg :
5205    
5206    c3d img1.nii -pad 10% 10% 1 -o padded.nii
5207    
5208    Adds 10% to all sides of the image, and fills the new voxels with the value
5209    1."""
5210    
5211    def run(
5212        self,
5213        execution: Execution,
5214    ) -> list[str]:
5215        """
5216        Build command line arguments. This method is called by the main command.
5217        
5218        Args:
5219            execution: The execution object.
5220        Returns:
5221            Command line arguments
5222        """
5223        cargs = []
5224        cargs.extend([
5225            "-pad",
5226            self.pad
5227        ])
5228        return cargs
5229
5230
5231@dataclasses.dataclass
5232class C3dPadTo:
5233    """
5234    No description found.
5235    """
5236    pad_to: str
5237    """No description found."""
5238    
5239    def run(
5240        self,
5241        execution: Execution,
5242    ) -> list[str]:
5243        """
5244        Build command line arguments. This method is called by the main command.
5245        
5246        Args:
5247            execution: The execution object.
5248        Returns:
5249            Command line arguments
5250        """
5251        cargs = []
5252        cargs.extend([
5253            "-padto",
5254            self.pad_to
5255        ])
5256        return cargs
5257
5258
5259@dataclasses.dataclass
5260class C3dPca:
5261    """
5262    -pca: Principal components analysis of foreground voxels
5263    
5264    Syntax: `-pca`
5265    
5266    Similar to the *-centroid* command, computes the centroid and prinicipal
5267    components of the foregrond voxels in the image. For example if the image is
5268    a binary image of an ellipsoid, this will report the center and the
5269    principal axes of the ellipsoid, in physical NIFTI coordinates.
5270    
5271    c3d binaryimage.img -pca // centroid of all non-0 voxels
5272    c3d labelimage.img -thresh 5 5 1 0 -pca // centroid of all voxels with label
5273    5
5274    c3d labelimage.img -split -foreach -pca -endfor // centroids of all labels
5275    (including 0).
5276    """
5277    pca: str
5278    """-pca: Principal components analysis of foreground voxels
5279    
5280    Syntax: `-pca`
5281    
5282    Similar to the *-centroid* command, computes the centroid and prinicipal
5283    components of the foregrond voxels in the image. For example if the image is
5284    a binary image of an ellipsoid, this will report the center and the
5285    principal axes of the ellipsoid, in physical NIFTI coordinates.
5286    
5287    c3d binaryimage.img -pca // centroid of all non-0 voxels
5288    c3d labelimage.img -thresh 5 5 1 0 -pca // centroid of all voxels with label
5289    5
5290    c3d labelimage.img -split -foreach -pca -endfor // centroids of all labels
5291    (including 0)"""
5292    
5293    def run(
5294        self,
5295        execution: Execution,
5296    ) -> list[str]:
5297        """
5298        Build command line arguments. This method is called by the main command.
5299        
5300        Args:
5301            execution: The execution object.
5302        Returns:
5303            Command line arguments
5304        """
5305        cargs = []
5306        cargs.extend([
5307            "-pca",
5308            self.pca
5309        ])
5310        return cargs
5311
5312
5313@dataclasses.dataclass
5314class C3dPercentIntensityMode:
5315    """
5316    -pim, -percent-intensity-mode: Set behavior of % specifier
5317    
5318    Syntax: `-pim Quantile | q | ForegroundQuantile | fq | Range | r`
5319    
5320    This options changes how the percent sign (%) is interpreted when specifying
5321    intensity values. **Quantile (q)** means that `10%` describes the 10th
5322    percentile of all intensity values in the image (i.e., 10% of the voxels
5323    have lower intensity). **ForegroundQuantile (fq)** is similar, but voxels
5324    with background intensity (see **-background** option) are excluded from the
5325    percentile computation. **Range (r)** changes the meaning of percent sign
5326    from percentile to the range between the minimum and maximum of the image,
5327    and `0.1%` becomes equal to MIN + 0.1 (MAX - MIN). The default is
5328    **Quantile**.
5329    
5330    $ c3d comp01.png -verbose -pim Quantile -verbose -threshold 75% inf 1 0
5331    Quantile 0.75 maps to 18
5332    
5333    $ c3d comp01.png -verbose -pim ForegroundQuantile -verbose -threshold 75%
5334    inf 1 0
5335    Foreground quantile 0.75 (over 37467 voxels) maps to 58
5336    
5337    $ c3d comp01.png -verbose -pim Range -verbose -threshold 75% inf 1 0
5338    Intensity range spec 0.75 maps to 191.25.
5339    """
5340    percent_intensity_mode: str
5341    """-pim, -percent-intensity-mode: Set behavior of % specifier
5342    
5343    Syntax: `-pim Quantile | q | ForegroundQuantile | fq | Range | r`
5344    
5345    This options changes how the percent sign (%) is interpreted when specifying
5346    intensity values. **Quantile (q)** means that `10%` describes the 10th
5347    percentile of all intensity values in the image (i.e., 10% of the voxels
5348    have lower intensity). **ForegroundQuantile (fq)** is similar, but voxels
5349    with background intensity (see **-background** option) are excluded from the
5350    percentile computation. **Range (r)** changes the meaning of percent sign
5351    from percentile to the range between the minimum and maximum of the image,
5352    and `0.1%` becomes equal to MIN + 0.1 (MAX - MIN). The default is
5353    **Quantile**.
5354    
5355    $ c3d comp01.png -verbose -pim Quantile -verbose -threshold 75% inf 1 0
5356    Quantile 0.75 maps to 18
5357    
5358    $ c3d comp01.png -verbose -pim ForegroundQuantile -verbose -threshold 75%
5359    inf 1 0
5360    Foreground quantile 0.75 (over 37467 voxels) maps to 58
5361    
5362    $ c3d comp01.png -verbose -pim Range -verbose -threshold 75% inf 1 0
5363    Intensity range spec 0.75 maps to 191.25"""
5364    
5365    def run(
5366        self,
5367        execution: Execution,
5368    ) -> list[str]:
5369        """
5370        Build command line arguments. This method is called by the main command.
5371        
5372        Args:
5373            execution: The execution object.
5374        Returns:
5375            Command line arguments
5376        """
5377        cargs = []
5378        cargs.extend([
5379            "-percent-intensity-mode",
5380            self.percent_intensity_mode
5381        ])
5382        return cargs
5383
5384
5385@dataclasses.dataclass
5386class C3dPixel:
5387    """
5388    No description found.
5389    """
5390    pixel: str
5391    """No description found."""
5392    
5393    def run(
5394        self,
5395        execution: Execution,
5396    ) -> list[str]:
5397        """
5398        Build command line arguments. This method is called by the main command.
5399        
5400        Args:
5401            execution: The execution object.
5402        Returns:
5403            Command line arguments
5404        """
5405        cargs = []
5406        cargs.extend([
5407            "-pixel",
5408            self.pixel
5409        ])
5410        return cargs
5411
5412
5413@dataclasses.dataclass
5414class C3dPop:
5415    """
5416    -pop: Remove last image from the stack
5417    
5418    Syntax: `-pop`
5419    
5420    Removes the last image from the image stack. Images assigned a name with the
5421    **-as** command will remain in memory.
5422    """
5423    pop_: str
5424    """-pop: Remove last image from the stack
5425    
5426    Syntax: `-pop`
5427    
5428    Removes the last image from the image stack. Images assigned a name with the
5429    **-as** command will remain in memory."""
5430    
5431    def run(
5432        self,
5433        execution: Execution,
5434    ) -> list[str]:
5435        """
5436        Build command line arguments. This method is called by the main command.
5437        
5438        Args:
5439            execution: The execution object.
5440        Returns:
5441            Command line arguments
5442        """
5443        cargs = []
5444        cargs.extend([
5445            "-pop",
5446            self.pop_
5447        ])
5448        return cargs
5449
5450
5451@dataclasses.dataclass
5452class C3dPopas:
5453    """
5454    -popas: Remove last image from the stack and assign to variable
5455    
5456    Syntax: `-popas var`
5457    
5458    Removes the last image from the stack, but also assigns it the name 'var',
5459    keeping the image in memory. Same as calling **-as** *var* followed by
5460    **-pop**.
5461    """
5462    popas: str
5463    """-popas: Remove last image from the stack and assign to variable
5464    
5465    Syntax: `-popas var`
5466    
5467    Removes the last image from the stack, but also assigns it the name 'var',
5468    keeping the image in memory. Same as calling **-as** *var* followed by
5469    **-pop**."""
5470    
5471    def run(
5472        self,
5473        execution: Execution,
5474    ) -> list[str]:
5475        """
5476        Build command line arguments. This method is called by the main command.
5477        
5478        Args:
5479            execution: The execution object.
5480        Returns:
5481            Command line arguments
5482        """
5483        cargs = []
5484        cargs.extend([
5485            "-popas",
5486            self.popas
5487        ])
5488        return cargs
5489
5490
5491@dataclasses.dataclass
5492class C3dProbe:
5493    """
5494    -probe: Report image intensity at a voxel
5495    
5496    Syntax: `-probe <point_spec>`
5497    
5498    Prints the value of the image at the position specified by the parameter
5499    `point_spec`, which may be in physical units or voxel units:
5500    
5501    c3d img1.img -probe 128x120x160vox
5502    c3d img1.img -interpolation NearestNeighbor -probe 60x60x60mm
5503    c3d img1.img -probe 50%.
5504    """
5505    probe: str
5506    """-probe: Report image intensity at a voxel
5507    
5508    Syntax: `-probe <point_spec>`
5509    
5510    Prints the value of the image at the position specified by the parameter
5511    `point_spec`, which may be in physical units or voxel units:
5512    
5513    c3d img1.img -probe 128x120x160vox
5514    c3d img1.img -interpolation NearestNeighbor -probe 60x60x60mm
5515    c3d img1.img -probe 50%"""
5516    
5517    def run(
5518        self,
5519        execution: Execution,
5520    ) -> list[str]:
5521        """
5522        Build command line arguments. This method is called by the main command.
5523        
5524        Args:
5525            execution: The execution object.
5526        Returns:
5527            Command line arguments
5528        """
5529        cargs = []
5530        cargs.extend([
5531            "-probe",
5532            self.probe
5533        ])
5534        return cargs
5535
5536
5537@dataclasses.dataclass
5538class C3dPush:
5539    """
5540    -push: Place variable at the end of the stack
5541    
5542    Syntax: `-push var`
5543    
5544    Places the image associated with variable name 'var' on end of the image
5545    stack. Variable names are assigned using the **-as** command. The **-as**
5546    and **-push** commands are useful when you need to use a certain image more
5547    than once during a convert3d operation. For example, if you want to compute
5548    the distance transform of a binary image and mask it so that the values
5549    outside of the binary image region have value 0, you would use the following
5550    command:
5551    
5552    c3d binary.img -as A -sdt -push A -times -o masked_distance.img.
5553    """
5554    push: str
5555    """-push: Place variable at the end of the stack
5556    
5557    Syntax: `-push var`
5558    
5559    Places the image associated with variable name 'var' on end of the image
5560    stack. Variable names are assigned using the **-as** command. The **-as**
5561    and **-push** commands are useful when you need to use a certain image more
5562    than once during a convert3d operation. For example, if you want to compute
5563    the distance transform of a binary image and mask it so that the values
5564    outside of the binary image region have value 0, you would use the following
5565    command:
5566    
5567    c3d binary.img -as A -sdt -push A -times -o masked_distance.img"""
5568    
5569    def run(
5570        self,
5571        execution: Execution,
5572    ) -> list[str]:
5573        """
5574        Build command line arguments. This method is called by the main command.
5575        
5576        Args:
5577            execution: The execution object.
5578        Returns:
5579            Command line arguments
5580        """
5581        cargs = []
5582        cargs.extend([
5583            "-push",
5584            self.push
5585        ])
5586        return cargs
5587
5588
5589@dataclasses.dataclass
5590class C3dRank:
5591    """
5592    -rank: Voxelwise ranking of intensity values
5593    
5594    Syntax: `-rank `
5595    
5596    This command takes N images as the input (all the images on the stack are
5597    used). It also generates N images as the output. For voxel k in image j, it
5598    assigns it a label based on its rank among the values of voxel k in all N
5599    images. If the voxel has highest intensity in image j, then the j'th output
5600    will have value 1.
5601    
5602    c3d img1.img img2.img ... imgN.img -rank -oo rank%d.img.
5603    """
5604    rank: str
5605    """-rank: Voxelwise ranking of intensity values
5606    
5607    Syntax: `-rank `
5608    
5609    This command takes N images as the input (all the images on the stack are
5610    used). It also generates N images as the output. For voxel k in image j, it
5611    assigns it a label based on its rank among the values of voxel k in all N
5612    images. If the voxel has highest intensity in image j, then the j'th output
5613    will have value 1.
5614    
5615    c3d img1.img img2.img ... imgN.img -rank -oo rank%d.img"""
5616    
5617    def run(
5618        self,
5619        execution: Execution,
5620    ) -> list[str]:
5621        """
5622        Build command line arguments. This method is called by the main command.
5623        
5624        Args:
5625            execution: The execution object.
5626        Returns:
5627            Command line arguments
5628        """
5629        cargs = []
5630        cargs.extend([
5631            "-rank",
5632            self.rank
5633        ])
5634        return cargs
5635
5636
5637@dataclasses.dataclass
5638class C3dReciprocal:
5639    """
5640    -reciprocal: Image voxelwise reciprocal
5641    
5642    Syntax: `-reciprocal `
5643    
5644    Computes the reciprocal of an image. For instance to compute B = 1 / A, use
5645    the command
5646    
5647    c3d A.img -reciprocal -o B.img.
5648    """
5649    reciprocal: str
5650    """-reciprocal: Image voxelwise reciprocal
5651    
5652    Syntax: `-reciprocal `
5653    
5654    Computes the reciprocal of an image. For instance to compute B = 1 / A, use
5655    the command
5656    
5657    c3d A.img -reciprocal -o B.img"""
5658    
5659    def run(
5660        self,
5661        execution: Execution,
5662    ) -> list[str]:
5663        """
5664        Build command line arguments. This method is called by the main command.
5665        
5666        Args:
5667            execution: The execution object.
5668        Returns:
5669            Command line arguments
5670        """
5671        cargs = []
5672        cargs.extend([
5673            "-reciprocal",
5674            self.reciprocal
5675        ])
5676        return cargs
5677
5678
5679@dataclasses.dataclass
5680class C3dRegion:
5681    """
5682    -region: Extract region from image
5683    
5684    Syntax: `-region vOrigin vSize `
5685    
5686    Extract a rectangular region from the image. The first parameter is the
5687    position of the corner of the region, and the second is the size of the
5688    region.
5689    
5690    c3d img1.img -region 20x20x20vox 50x60x70vox -o img2.img
5691    c3d img1.img -region 25% 50% -o img3.img.
5692    """
5693    region: str
5694    """-region: Extract region from image
5695    
5696    Syntax: `-region vOrigin vSize `
5697    
5698    Extract a rectangular region from the image. The first parameter is the
5699    position of the corner of the region, and the second is the size of the
5700    region.
5701    
5702    c3d img1.img -region 20x20x20vox 50x60x70vox -o img2.img
5703    c3d img1.img -region 25% 50% -o img3.img"""
5704    
5705    def run(
5706        self,
5707        execution: Execution,
5708    ) -> list[str]:
5709        """
5710        Build command line arguments. This method is called by the main command.
5711        
5712        Args:
5713            execution: The execution object.
5714        Returns:
5715            Command line arguments
5716        """
5717        cargs = []
5718        cargs.extend([
5719            "-region",
5720            self.region
5721        ])
5722        return cargs
5723
5724
5725@dataclasses.dataclass
5726class C3dReorder:
5727    """
5728    -reorder: Rearrange images on the stack
5729    
5730    Syntax: `-reorder k` or `-reorder fraction`
5731    
5732    Rearranges images in the stack, such that images that are k positions apart
5733    become next to each other on the stack. In other words, if the original
5734    order of the images is 1, 2, ..., n, the new order of the images becomes 1,
5735    1+k, 1+2k, ..., 2, 2+k, 2+2k, ..., k, 2k, ... n. Of course, n must be
5736    divisible by k. As an alternative to specifying k, you can specify a
5737    floating point number (i.e., **-reorder** 0.5), in which case k is obtained
5738    by multiplying n by the floating point number and rounding to the nearest
5739    integer.
5740    
5741    The following three commands are equivalent:
5742    
5743    c3d a1.nii a2.nii a3.nii a4.nii b1.nii b2.nii b3.nii b4.nii -reorder 4 ...
5744    c3d a1.nii a2.nii a3.nii a4.nii b1.nii b2.nii b3.nii b4.nii -reorder 0.5 ...
5745    c3d a1.nii b1.nii a2.nii b2.nii a3.nii b3.nii a4.nii b4.nii ...
5746    
5747    The **-reorder** command us useful when you specify two sets of images using
5748    wildcards and then want to perform pairwise operations on the images. For
5749    example
5750    
5751    c3d weight*.nii gray*.nii -reorder 0.5 -weighted-sum-voxelwise -o wsum.nii
5752    
5753    is equivalent to the command
5754    
5755    c3d weight1.nii gray1.nii weight2.nii gray2.nii ... -weighted-sum-voxelwise
5756    -o wsum.nii.
5757    """
5758    reorder: str
5759    """-reorder: Rearrange images on the stack
5760    
5761    Syntax: `-reorder k` or `-reorder fraction`
5762    
5763    Rearranges images in the stack, such that images that are k positions apart
5764    become next to each other on the stack. In other words, if the original
5765    order of the images is 1, 2, ..., n, the new order of the images becomes 1,
5766    1+k, 1+2k, ..., 2, 2+k, 2+2k, ..., k, 2k, ... n. Of course, n must be
5767    divisible by k. As an alternative to specifying k, you can specify a
5768    floating point number (i.e., **-reorder** 0.5), in which case k is obtained
5769    by multiplying n by the floating point number and rounding to the nearest
5770    integer.
5771    
5772    The following three commands are equivalent:
5773    
5774    c3d a1.nii a2.nii a3.nii a4.nii b1.nii b2.nii b3.nii b4.nii -reorder 4 ...
5775    c3d a1.nii a2.nii a3.nii a4.nii b1.nii b2.nii b3.nii b4.nii -reorder 0.5 ...
5776    c3d a1.nii b1.nii a2.nii b2.nii a3.nii b3.nii a4.nii b4.nii ...
5777    
5778    The **-reorder** command us useful when you specify two sets of images using
5779    wildcards and then want to perform pairwise operations on the images. For
5780    example
5781    
5782    c3d weight*.nii gray*.nii -reorder 0.5 -weighted-sum-voxelwise -o wsum.nii
5783    
5784    is equivalent to the command
5785    
5786    c3d weight1.nii gray1.nii weight2.nii gray2.nii ... -weighted-sum-voxelwise
5787    -o wsum.nii"""
5788    
5789    def run(
5790        self,
5791        execution: Execution,
5792    ) -> list[str]:
5793        """
5794        Build command line arguments. This method is called by the main command.
5795        
5796        Args:
5797            execution: The execution object.
5798        Returns:
5799            Command line arguments
5800        """
5801        cargs = []
5802        cargs.extend([
5803            "-reorder",
5804            self.reorder
5805        ])
5806        return cargs
5807
5808
5809@dataclasses.dataclass
5810class C3dRetainLabels:
5811    """
5812    -retain-labels: Retain labels in a label image
5813    
5814    Syntax: `-retain-labels I1 I2 ... IN`
5815    
5816    Assuming that the input is a multi-label segmentation image, this command
5817    keeps all labels specifed in the list and replaces the remaining labels with
5818    the background value.
5819    
5820    c3d seg.nii -retain-labels 2 3 4 8 -o subseg.nii.
5821    """
5822    retain_labels: str
5823    """-retain-labels: Retain labels in a label image
5824    
5825    Syntax: `-retain-labels I1 I2 ... IN`
5826    
5827    Assuming that the input is a multi-label segmentation image, this command
5828    keeps all labels specifed in the list and replaces the remaining labels with
5829    the background value.
5830    
5831    c3d seg.nii -retain-labels 2 3 4 8 -o subseg.nii"""
5832    
5833    def run(
5834        self,
5835        execution: Execution,
5836    ) -> list[str]:
5837        """
5838        Build command line arguments. This method is called by the main command.
5839        
5840        Args:
5841            execution: The execution object.
5842        Returns:
5843            Command line arguments
5844        """
5845        cargs = []
5846        cargs.extend([
5847            "-retain-labels",
5848            self.retain_labels
5849        ])
5850        return cargs
5851
5852
5853@dataclasses.dataclass
5854class C3dRfApply:
5855    """
5856    -rf-apply: Apply Random Forest classifier
5857    
5858    Syntax: `-rf-apply <classifier_file>`
5859    
5860    This command applies a classifier trained previously by **-rf-train**. The
5861    stack must contain the same number of feature images as when training. The
5862    images will be removed from the stack and replaced with a set of K
5863    probability images, where K is the number of classes during training. See
5864    examples under **-rf-train** for usage.
5865    """
5866    rf_apply: str
5867    """-rf-apply: Apply Random Forest classifier
5868    
5869    Syntax: `-rf-apply <classifier_file>`
5870    
5871    This command applies a classifier trained previously by **-rf-train**. The
5872    stack must contain the same number of feature images as when training. The
5873    images will be removed from the stack and replaced with a set of K
5874    probability images, where K is the number of classes during training. See
5875    examples under **-rf-train** for usage."""
5876    
5877    def run(
5878        self,
5879        execution: Execution,
5880    ) -> list[str]:
5881        """
5882        Build command line arguments. This method is called by the main command.
5883        
5884        Args:
5885            execution: The execution object.
5886        Returns:
5887            Command line arguments
5888        """
5889        cargs = []
5890        cargs.extend([
5891            "-rf-apply",
5892            self.rf_apply
5893        ])
5894        return cargs
5895
5896
5897@dataclasses.dataclass
5898class C3dRfTrain:
5899    """
5900    -rf-train: Train Random Forest classifier
5901    
5902    Syntax: `-rf-train <classifier_file>`
5903    
5904    This command trains a classifier using an implementation of the [Breyman et
5905    al. Random Forest Algorithm][Br2001], with modifications proposed by
5906    [Criminisi and Shotton][Cr2004]. The stack must contain one or more images
5907    of features (e.g., grayscale images), followed by a multi-label image. The
5908    latter must have at least two non-zero labels corresponding to different
5909    classes. The classifier is trained on a voxel by voxel basis. All voxels
5910    with label *L* are treated as the examples of class *L*. The classifier is
5911    output to a binary file that can later be used by the **-rf-apply** command.
5912    Multiple parameters can be specified with the **-rf-param-xxx** options
5913    before calling **-rf-train**. The stack is not modified by this command.
5914    
5915    # Training with two MRI modalities as features and default parameters
5916    c3d t1_mri.nii t2_mri.nii segmentation.nii -rf-train myforest1.rf
5917    
5918    # Training with patches as features (see docs for -rf-param-patch)
5919    c3d ultrasound.nii seg.nii -rf-param-patch 2x2x2 -rf-train myforest2.rf
5920    
5921    # Applying the classifier
5922    c3d ultrasound.nii -rf-apply myforest2.rf -omc class_prob.nii.gz
5923    
5924    The commands are meant to replicate the "classification" pre-segmentation
5925    mode in ITK-SNAP, i.e., extending a rough example segmentation to the entire
5926    image domain. It is possible to also use the commands to train classifiers
5927    jointly on data from multiple subjects, each with its own segmentation, as
5928    long as the images from the different subjects occupy the same image space
5929    and can be stacked into a 4-dimensional image. For example:
5930    
5931    # Train using MRI and segmentations from N subjects
5932    c4d mri_subj*.nii -tile w -popas ALLMRI \
5933    seg_subj*.nii -tile w -popas ALLSEG \
5934    -rf-param-patch 2x2x2x0 \
5935    -push ALLMRI -push ALLSEG -rf-train myforest.rf
5936    
5937    # Apply using single MRI
5938    c4d mri_new.nii -rf-apply myforest.rf -omc classprob.nii
5939    
5940    [Br2001] Breiman, L. (2001). Random forests. Machine learning, 45(1), 5-32.
5941    [Cr2004] Criminisi, A., & Shotton, J. (2013). Decision forests for computer
5942    vision and medical image analysis. Springer Science & Business Media.
5943    """
5944    rf_train: str
5945    """-rf-train: Train Random Forest classifier
5946    
5947    Syntax: `-rf-train <classifier_file>`
5948    
5949    This command trains a classifier using an implementation of the [Breyman et
5950    al. Random Forest Algorithm][Br2001], with modifications proposed by
5951    [Criminisi and Shotton][Cr2004]. The stack must contain one or more images
5952    of features (e.g., grayscale images), followed by a multi-label image. The
5953    latter must have at least two non-zero labels corresponding to different
5954    classes. The classifier is trained on a voxel by voxel basis. All voxels
5955    with label *L* are treated as the examples of class *L*. The classifier is
5956    output to a binary file that can later be used by the **-rf-apply** command.
5957    Multiple parameters can be specified with the **-rf-param-xxx** options
5958    before calling **-rf-train**. The stack is not modified by this command.
5959    
5960    # Training with two MRI modalities as features and default parameters
5961    c3d t1_mri.nii t2_mri.nii segmentation.nii -rf-train myforest1.rf
5962    
5963    # Training with patches as features (see docs for -rf-param-patch)
5964    c3d ultrasound.nii seg.nii -rf-param-patch 2x2x2 -rf-train myforest2.rf
5965    
5966    # Applying the classifier
5967    c3d ultrasound.nii -rf-apply myforest2.rf -omc class_prob.nii.gz
5968    
5969    The commands are meant to replicate the "classification" pre-segmentation
5970    mode in ITK-SNAP, i.e., extending a rough example segmentation to the entire
5971    image domain. It is possible to also use the commands to train classifiers
5972    jointly on data from multiple subjects, each with its own segmentation, as
5973    long as the images from the different subjects occupy the same image space
5974    and can be stacked into a 4-dimensional image. For example:
5975    
5976    # Train using MRI and segmentations from N subjects
5977    c4d mri_subj*.nii -tile w -popas ALLMRI \
5978    seg_subj*.nii -tile w -popas ALLSEG \
5979    -rf-param-patch 2x2x2x0 \
5980    -push ALLMRI -push ALLSEG -rf-train myforest.rf
5981    
5982    # Apply using single MRI
5983    c4d mri_new.nii -rf-apply myforest.rf -omc classprob.nii
5984    
5985    [Br2001] Breiman, L. (2001). Random forests. Machine learning, 45(1), 5-32.
5986    [Cr2004] Criminisi, A., & Shotton, J. (2013). Decision forests for computer
5987    vision and medical image analysis. Springer Science & Business Media"""
5988    
5989    def run(
5990        self,
5991        execution: Execution,
5992    ) -> list[str]:
5993        """
5994        Build command line arguments. This method is called by the main command.
5995        
5996        Args:
5997            execution: The execution object.
5998        Returns:
5999            Command line arguments
6000        """
6001        cargs = []
6002        cargs.extend([
6003            "-rf-train",
6004            self.rf_train
6005        ])
6006        return cargs
6007
6008
6009@dataclasses.dataclass
6010class C3dRfParamPatch:
6011    """
6012    -rf-param-patch: Random Forest training patch size
6013    
6014    Syntax: `-rf-param-patch <size_spec>`
6015    
6016    Set the radius of the patch used to generate features for the RF classifier.
6017    By default this is zero, which means that just the intensity of each voxel
6018    is used as a feature. Setting this to non-zero values will result in
6019    neighboring intensities also being used as features, and can improve
6020    classification in presence of complex image texture. The patch size in each
6021    dimension is (2 * radius + 1). See **-rf-train** command for details.
6022    
6023    # Set patch size to 5x5x5
6024    c3d ... -rf-param-patch 2x2x2 ... -rf-train myforest.rf.
6025    """
6026    rf_param_patch: str
6027    """-rf-param-patch: Random Forest training patch size
6028    
6029    Syntax: `-rf-param-patch <size_spec>`
6030    
6031    Set the radius of the patch used to generate features for the RF classifier.
6032    By default this is zero, which means that just the intensity of each voxel
6033    is used as a feature. Setting this to non-zero values will result in
6034    neighboring intensities also being used as features, and can improve
6035    classification in presence of complex image texture. The patch size in each
6036    dimension is (2 * radius + 1). See **-rf-train** command for details.
6037    
6038    # Set patch size to 5x5x5
6039    c3d ... -rf-param-patch 2x2x2 ... -rf-train myforest.rf"""
6040    
6041    def run(
6042        self,
6043        execution: Execution,
6044    ) -> list[str]:
6045        """
6046        Build command line arguments. This method is called by the main command.
6047        
6048        Args:
6049            execution: The execution object.
6050        Returns:
6051            Command line arguments
6052        """
6053        cargs = []
6054        cargs.extend([
6055            "-rf-param-patch",
6056            self.rf_param_patch
6057        ])
6058        return cargs
6059
6060
6061@dataclasses.dataclass
6062class C3dRfParamUsexyz:
6063    """
6064    -rf-param-usexyz: Random Forest coordinate features
6065    
6066    Syntax: `-rf-param-usexyz`
6067    
6068    Use the coordinates of voxels as additional features. This allows some
6069    geometric relations between different labels to be learned. Equivalent to
6070    the corresponding ITK-SNAP option.
6071    """
6072    rf_param_usexyz: str
6073    """-rf-param-usexyz: Random Forest coordinate features
6074    
6075    Syntax: `-rf-param-usexyz`
6076    
6077    Use the coordinates of voxels as additional features. This allows some
6078    geometric relations between different labels to be learned. Equivalent to
6079    the corresponding ITK-SNAP option."""
6080    
6081    def run(
6082        self,
6083        execution: Execution,
6084    ) -> list[str]:
6085        """
6086        Build command line arguments. This method is called by the main command.
6087        
6088        Args:
6089            execution: The execution object.
6090        Returns:
6091            Command line arguments
6092        """
6093        cargs = []
6094        cargs.extend([
6095            "-rf-param-usexyz",
6096            self.rf_param_usexyz
6097        ])
6098        return cargs
6099
6100
6101@dataclasses.dataclass
6102class C3dRfParamNousexyz:
6103    """
6104    No description found.
6105    """
6106    rf_param_nousexyz: str
6107    """No description found."""
6108    
6109    def run(
6110        self,
6111        execution: Execution,
6112    ) -> list[str]:
6113        """
6114        Build command line arguments. This method is called by the main command.
6115        
6116        Args:
6117            execution: The execution object.
6118        Returns:
6119            Command line arguments
6120        """
6121        cargs = []
6122        cargs.extend([
6123            "-rf-param-nousexyz",
6124            self.rf_param_nousexyz
6125        ])
6126        return cargs
6127
6128
6129@dataclasses.dataclass
6130class C3dRfParamNtrees:
6131    """
6132    -rf-param-ntrees: Random Forest forest size
6133    
6134    Syntax: `-rf-param-ntrees <integer>`
6135    
6136    Sets the number of trees in the forest. Default value is 50. Larger forests
6137    are more robust but more time to train and apply.
6138    """
6139    rf_param_ntrees: str
6140    """-rf-param-ntrees: Random Forest forest size
6141    
6142    Syntax: `-rf-param-ntrees <integer>`
6143    
6144    Sets the number of trees in the forest. Default value is 50. Larger forests
6145    are more robust but more time to train and apply."""
6146    
6147    def run(
6148        self,
6149        execution: Execution,
6150    ) -> list[str]:
6151        """
6152        Build command line arguments. This method is called by the main command.
6153        
6154        Args:
6155            execution: The execution object.
6156        Returns:
6157            Command line arguments
6158        """
6159        cargs = []
6160        cargs.extend([
6161            "-rf-param-ntrees",
6162            self.rf_param_ntrees
6163        ])
6164        return cargs
6165
6166
6167@dataclasses.dataclass
6168class C3dRfParamTreedepth:
6169    """
6170    -rf-param-treedepth: Random Forest tree depth
6171    
6172    Syntax: `-rf-param-treedepth <integer>`
6173    
6174    Sets the depth of the trees in the classifier. Default value is 30. Deeper
6175    trees can learn on more complex data but require more time.
6176    """
6177    rf_param_treedepth: str
6178    """-rf-param-treedepth: Random Forest tree depth
6179    
6180    Syntax: `-rf-param-treedepth <integer>`
6181    
6182    Sets the depth of the trees in the classifier. Default value is 30. Deeper
6183    trees can learn on more complex data but require more time."""
6184    
6185    def run(
6186        self,
6187        execution: Execution,
6188    ) -> list[str]:
6189        """
6190        Build command line arguments. This method is called by the main command.
6191        
6192        Args:
6193            execution: The execution object.
6194        Returns:
6195            Command line arguments
6196        """
6197        cargs = []
6198        cargs.extend([
6199            "-rf-param-treedepth",
6200            self.rf_param_treedepth
6201        ])
6202        return cargs
6203
6204
6205@dataclasses.dataclass
6206class C3dSetSform:
6207    """
6208    -set-sform: Set the transform to physical space
6209    
6210    Syntax: `-set-sform <sform.mat> `
6211    
6212    Sets the Nifti sform of the last image on the stack to the 4x4 matrix
6213    provided.
6214    """
6215    set_sform: str
6216    """-set-sform: Set the transform to physical space
6217    
6218    Syntax: `-set-sform <sform.mat> `
6219    
6220    Sets the Nifti sform of the last image on the stack to the 4x4 matrix
6221    provided."""
6222    
6223    def run(
6224        self,
6225        execution: Execution,
6226    ) -> list[str]:
6227        """
6228        Build command line arguments. This method is called by the main command.
6229        
6230        Args:
6231            execution: The execution object.
6232        Returns:
6233            Command line arguments
6234        """
6235        cargs = []
6236        cargs.extend([
6237            "-set-sform",
6238            self.set_sform
6239        ])
6240        return cargs
6241
6242
6243@dataclasses.dataclass
6244class C3dReplace:
6245    """
6246    -replace: Replace intensities in image
6247    
6248    Syntax: `-replace I1 J1 I2 J2 ... `
6249    
6250    Replace intensity I1 by J1, I2 by J2 and so on. Allowed values of intensity
6251    include **nan**, **inf** and **-inf**.
6252    
6253    c3d img1.img -replace 1 128 nan 0.0 -o img2.img.
6254    """
6255    replace: str
6256    """-replace: Replace intensities in image
6257    
6258    Syntax: `-replace I1 J1 I2 J2 ... `
6259    
6260    Replace intensity I1 by J1, I2 by J2 and so on. Allowed values of intensity
6261    include **nan**, **inf** and **-inf**.
6262    
6263    c3d img1.img -replace 1 128 nan 0.0 -o img2.img"""
6264    
6265    def run(
6266        self,
6267        execution: Execution,
6268    ) -> list[str]:
6269        """
6270        Build command line arguments. This method is called by the main command.
6271        
6272        Args:
6273            execution: The execution object.
6274        Returns:
6275            Command line arguments
6276        """
6277        cargs = []
6278        cargs.extend([
6279            "-replace",
6280            self.replace
6281        ])
6282        return cargs
6283
6284
6285@dataclasses.dataclass
6286class C3dResample:
6287    """
6288    -resample: Resample image to new dimensions
6289    
6290    Syntax: `-resample <dimensions> `
6291    
6292    Resamples the image, keeping the bounding box the same, but changing the
6293    number of voxels in the image. The dimensions can be specified as a
6294    percentage, for example to double the number of voxels in each direction.
6295    The **-interpolation** flag affects how sampling is performed.
6296    
6297    c3d img1.img -resample 123x142x200 -o img2.img
6298    c3d img1.img -resample 200% -o img2.img
6299    c3d img1.img -resample 100x100x200% -o img2.img
6300    c3d img1.img -background 4.0 -interpolation Cubic -resample 123x142x200 -o
6301    img2.img.
6302    """
6303    resample: str
6304    """-resample: Resample image to new dimensions
6305    
6306    Syntax: `-resample <dimensions> `
6307    
6308    Resamples the image, keeping the bounding box the same, but changing the
6309    number of voxels in the image. The dimensions can be specified as a
6310    percentage, for example to double the number of voxels in each direction.
6311    The **-interpolation** flag affects how sampling is performed.
6312    
6313    c3d img1.img -resample 123x142x200 -o img2.img
6314    c3d img1.img -resample 200% -o img2.img
6315    c3d img1.img -resample 100x100x200% -o img2.img
6316    c3d img1.img -background 4.0 -interpolation Cubic -resample 123x142x200 -o
6317    img2.img"""
6318    
6319    def run(
6320        self,
6321        execution: Execution,
6322    ) -> list[str]:
6323        """
6324        Build command line arguments. This method is called by the main command.
6325        
6326        Args:
6327            execution: The execution object.
6328        Returns:
6329            Command line arguments
6330        """
6331        cargs = []
6332        cargs.extend([
6333            "-resample",
6334            self.resample
6335        ])
6336        return cargs
6337
6338
6339@dataclasses.dataclass
6340class C3dResampleIso:
6341    """
6342    -resample-iso: Resample image to (approximately) isotropic resolution
6343    
6344    Syntax: `-resample-iso <min|max>`
6345    
6346    Resamples the image to have approximately isotropic resolution, either based
6347    on the smallest voxel dimension ('min' mode) or largest voxel dimension
6348    ('max' mode). This command calls **-resample** with appropriately calculated
6349    new image dimensions. The bounding box of the image in physical space is
6350    preserved. Therefore, since the image dimensions must be integer, the actual
6351    voxel dimensions after resampling may not be precisely isotropic.
6352    
6353    c3d img1.img -resample-iso min -o img2.img.
6354    """
6355    resample_iso: str
6356    """-resample-iso: Resample image to (approximately) isotropic resolution
6357    
6358    Syntax: `-resample-iso <min|max>`
6359    
6360    Resamples the image to have approximately isotropic resolution, either based
6361    on the smallest voxel dimension ('min' mode) or largest voxel dimension
6362    ('max' mode). This command calls **-resample** with appropriately calculated
6363    new image dimensions. The bounding box of the image in physical space is
6364    preserved. Therefore, since the image dimensions must be integer, the actual
6365    voxel dimensions after resampling may not be precisely isotropic.
6366    
6367    c3d img1.img -resample-iso min -o img2.img"""
6368    
6369    def run(
6370        self,
6371        execution: Execution,
6372    ) -> list[str]:
6373        """
6374        Build command line arguments. This method is called by the main command.
6375        
6376        Args:
6377            execution: The execution object.
6378        Returns:
6379            Command line arguments
6380        """
6381        cargs = []
6382        cargs.extend([
6383            "-resample-iso",
6384            self.resample_iso
6385        ])
6386        return cargs
6387
6388
6389@dataclasses.dataclass
6390class C3dResampleMm:
6391    """
6392    -resample-mm: Resample image to new resolution
6393    
6394    Syntax: `-resample-mm <voxel_size> `
6395    
6396    Resamples the image as in **-resample**, but the user specifies the new
6397    voxel size rather than dimensions. This may not be precise, so the bounding
6398    box of the image may change. A warning will be generated in that case.
6399    
6400    c3d img1.img -resample-mm 1.0x1.5x1.5mm -o img2.img.
6401    """
6402    resample_mm: str
6403    """-resample-mm: Resample image to new resolution
6404    
6405    Syntax: `-resample-mm <voxel_size> `
6406    
6407    Resamples the image as in **-resample**, but the user specifies the new
6408    voxel size rather than dimensions. This may not be precise, so the bounding
6409    box of the image may change. A warning will be generated in that case.
6410    
6411    c3d img1.img -resample-mm 1.0x1.5x1.5mm -o img2.img"""
6412    
6413    def run(
6414        self,
6415        execution: Execution,
6416    ) -> list[str]:
6417        """
6418        Build command line arguments. This method is called by the main command.
6419        
6420        Args:
6421            execution: The execution object.
6422        Returns:
6423            Command line arguments
6424        """
6425        cargs = []
6426        cargs.extend([
6427            "-resample-mm",
6428            self.resample_mm
6429        ])
6430        return cargs
6431
6432
6433@dataclasses.dataclass
6434class C3dResliceItk:
6435    """
6436    -reslice-itk: Resample image using affine transform
6437    
6438    Syntax: `-reslice-itk <transform_file> `
6439    
6440    Applies affine (or other) transform in ITK (ANTs) format to an image. See
6441    notes to **-reslice-matrix** for usage.
6442    """
6443    reslice_itk: str
6444    """-reslice-itk: Resample image using affine transform
6445    
6446    Syntax: `-reslice-itk <transform_file> `
6447    
6448    Applies affine (or other) transform in ITK (ANTs) format to an image. See
6449    notes to **-reslice-matrix** for usage."""
6450    
6451    def run(
6452        self,
6453        execution: Execution,
6454    ) -> list[str]:
6455        """
6456        Build command line arguments. This method is called by the main command.
6457        
6458        Args:
6459            execution: The execution object.
6460        Returns:
6461            Command line arguments
6462        """
6463        cargs = []
6464        cargs.extend([
6465            "-reslice-itk",
6466            self.reslice_itk
6467        ])
6468        return cargs
6469
6470
6471@dataclasses.dataclass
6472class C3dResliceMatrix:
6473    """
6474    No description found.
6475    """
6476    reslice_matrix: str
6477    """No description found."""
6478    
6479    def run(
6480        self,
6481        execution: Execution,
6482    ) -> list[str]:
6483        """
6484        Build command line arguments. This method is called by the main command.
6485        
6486        Args:
6487            execution: The execution object.
6488        Returns:
6489            Command line arguments
6490        """
6491        cargs = []
6492        cargs.extend([
6493            "-reslice-matrix",
6494            self.reslice_matrix
6495        ])
6496        return cargs
6497
6498
6499@dataclasses.dataclass
6500class C3dResliceIdentity:
6501    """
6502    -reslice-identity: Resample image using identity transform
6503    
6504    Syntax: `-reslice-identity `
6505    
6506    Applies the **-reslice-matrix** command with the identity transform. This is
6507    useful when you have two scans of the same subject with different coordinate
6508    transformations to patient space and you want to resample one scan in the
6509    space of another scan. For example, if you have T1 and T2 images in
6510    different coordinate frames, and want to reslice the T2 image into the space
6511    of the T1
6512    
6513    c3d t1.nii t2.nii -reslice-identity -o t2_in_t1_space.nii.
6514    """
6515    reslice_identity: str
6516    """-reslice-identity: Resample image using identity transform
6517    
6518    Syntax: `-reslice-identity `
6519    
6520    Applies the **-reslice-matrix** command with the identity transform. This is
6521    useful when you have two scans of the same subject with different coordinate
6522    transformations to patient space and you want to resample one scan in the
6523    space of another scan. For example, if you have T1 and T2 images in
6524    different coordinate frames, and want to reslice the T2 image into the space
6525    of the T1
6526    
6527    c3d t1.nii t2.nii -reslice-identity -o t2_in_t1_space.nii"""
6528    
6529    def run(
6530        self,
6531        execution: Execution,
6532    ) -> list[str]:
6533        """
6534        Build command line arguments. This method is called by the main command.
6535        
6536        Args:
6537            execution: The execution object.
6538        Returns:
6539            Command line arguments
6540        """
6541        cargs = []
6542        cargs.extend([
6543            "-reslice-identity",
6544            self.reslice_identity
6545        ])
6546        return cargs
6547
6548
6549@dataclasses.dataclass
6550class C3dRgb2hsv:
6551    """
6552    -rgb2hsv: Convert RGB image to HSV image
6553    
6554    Syntax `-rgb2hsv`
6555    
6556    Takes the last three images on the stack and treats them as red, green, and
6557    blue channels. Outputs three images corresponding to hue, saturation, value.
6558    To read color images you need the ***-msc*** command.
6559    
6560    c3d -mcs color.png -rgb2hsv -omc hsv.png.
6561    """
6562    rgb2hsv: str
6563    """-rgb2hsv: Convert RGB image to HSV image
6564    
6565    Syntax `-rgb2hsv`
6566    
6567    Takes the last three images on the stack and treats them as red, green, and
6568    blue channels. Outputs three images corresponding to hue, saturation, value.
6569    To read color images you need the ***-msc*** command.
6570    
6571    c3d -mcs color.png -rgb2hsv -omc hsv.png"""
6572    
6573    def run(
6574        self,
6575        execution: Execution,
6576    ) -> list[str]:
6577        """
6578        Build command line arguments. This method is called by the main command.
6579        
6580        Args:
6581            execution: The execution object.
6582        Returns:
6583            Command line arguments
6584        """
6585        cargs = []
6586        cargs.extend([
6587            "-rgb2hsv",
6588            self.rgb2hsv
6589        ])
6590        return cargs
6591
6592
6593@dataclasses.dataclass
6594class C3dRms:
6595    """
6596    -rms: Voxelwise vector norm
6597    
6598    Syntax: `-rms`
6599    
6600    Computes RMS (root mean square) of all images on the stack. The command
6601    takes the square of each image on the stack, adds all the squared images and
6602    takes the square root of the result. This is very useful for statistical
6603    operations. Images must have the same size.
6604    
6605    c3d img1.img img2.img img3.img img4.img -rms -o rms.img
6606    
6607    The equivalent of this command is
6608    
6609    c3d img1.img img2.img img3.img img4.img -foreach -dup -times -endfor \
6610    -accum -add -endaccum -sqrt -o rms.img.
6611    """
6612    rms: str
6613    """-rms: Voxelwise vector norm
6614    
6615    Syntax: `-rms`
6616    
6617    Computes RMS (root mean square) of all images on the stack. The command
6618    takes the square of each image on the stack, adds all the squared images and
6619    takes the square root of the result. This is very useful for statistical
6620    operations. Images must have the same size.
6621    
6622    c3d img1.img img2.img img3.img img4.img -rms -o rms.img
6623    
6624    The equivalent of this command is
6625    
6626    c3d img1.img img2.img img3.img img4.img -foreach -dup -times -endfor \
6627    -accum -add -endaccum -sqrt -o rms.img"""
6628    
6629    def run(
6630        self,
6631        execution: Execution,
6632    ) -> list[str]:
6633        """
6634        Build command line arguments. This method is called by the main command.
6635        
6636        Args:
6637            execution: The execution object.
6638        Returns:
6639            Command line arguments
6640        """
6641        cargs = []
6642        cargs.extend([
6643            "-rms",
6644            self.rms
6645        ])
6646        return cargs
6647
6648
6649@dataclasses.dataclass
6650class C3dRound:
6651    """
6652    -noround, -round: Floating point rounding behavior
6653    
6654    Syntax: `-noround` or `-round `
6655    
6656    By default, **convert3d** will round floating point values when converting
6657    to an integer, short or byte image. This command specifies that rounding
6658    should not be used. Rounding is used to avoid numerical errors stemming from
6659    the internal floating point representation.
6660    
6661    c3d image1.img -type short -noround image2.img.
6662    """
6663    round_: str
6664    """-noround, -round: Floating point rounding behavior
6665    
6666    Syntax: `-noround` or `-round `
6667    
6668    By default, **convert3d** will round floating point values when converting
6669    to an integer, short or byte image. This command specifies that rounding
6670    should not be used. Rounding is used to avoid numerical errors stemming from
6671    the internal floating point representation.
6672    
6673    c3d image1.img -type short -noround image2.img"""
6674    
6675    def run(
6676        self,
6677        execution: Execution,
6678    ) -> list[str]:
6679        """
6680        Build command line arguments. This method is called by the main command.
6681        
6682        Args:
6683            execution: The execution object.
6684        Returns:
6685            Command line arguments
6686        """
6687        cargs = []
6688        cargs.extend([
6689            "-round",
6690            self.round_
6691        ])
6692        return cargs
6693
6694
6695@dataclasses.dataclass
6696class C3dScale:
6697    """
6698    -scale: Scale intensity by constant factor
6699    
6700    Syntax: `-scale <factor>`
6701    
6702    Multiplies the intensity of each voxel in the last image on the stack by the
6703    given factor.
6704    
6705    c3d img1.img -scale 0.5 -o img2.img.
6706    """
6707    scale: str
6708    """-scale: Scale intensity by constant factor
6709    
6710    Syntax: `-scale <factor>`
6711    
6712    Multiplies the intensity of each voxel in the last image on the stack by the
6713    given factor.
6714    
6715    c3d img1.img -scale 0.5 -o img2.img"""
6716    
6717    def run(
6718        self,
6719        execution: Execution,
6720    ) -> list[str]:
6721        """
6722        Build command line arguments. This method is called by the main command.
6723        
6724        Args:
6725            execution: The execution object.
6726        Returns:
6727            Command line arguments
6728        """
6729        cargs = []
6730        cargs.extend([
6731            "-scale",
6732            self.scale
6733        ])
6734        return cargs
6735
6736
6737@dataclasses.dataclass
6738class C3dSetSform_:
6739    """
6740    -set-sform: Set the transform to physical space
6741    
6742    Syntax: `-set-sform <sform.mat> `
6743    
6744    Sets the Nifti sform of the last image on the stack to the 4x4 matrix
6745    provided.
6746    """
6747    set_sform: str
6748    """-set-sform: Set the transform to physical space
6749    
6750    Syntax: `-set-sform <sform.mat> `
6751    
6752    Sets the Nifti sform of the last image on the stack to the 4x4 matrix
6753    provided."""
6754    
6755    def run(
6756        self,
6757        execution: Execution,
6758    ) -> list[str]:
6759        """
6760        Build command line arguments. This method is called by the main command.
6761        
6762        Args:
6763            execution: The execution object.
6764        Returns:
6765            Command line arguments
6766        """
6767        cargs = []
6768        cargs.extend([
6769            "-set-sform",
6770            self.set_sform
6771        ])
6772        return cargs
6773
6774
6775@dataclasses.dataclass
6776class C3dSin:
6777    """
6778    -cos: Voxelwise cosine
6779    
6780    Syntax: `-sin`
6781    
6782    Replaces the last image on the stack with the cosine trigonometric operation
6783    applied to all voxels. Input must be in radians.
6784    """
6785    sin: str
6786    """-cos: Voxelwise cosine
6787    
6788    Syntax: `-sin`
6789    
6790    Replaces the last image on the stack with the cosine trigonometric operation
6791    applied to all voxels. Input must be in radians."""
6792    
6793    def run(
6794        self,
6795        execution: Execution,
6796    ) -> list[str]:
6797        """
6798        Build command line arguments. This method is called by the main command.
6799        
6800        Args:
6801            execution: The execution object.
6802        Returns:
6803            Command line arguments
6804        """
6805        cargs = []
6806        cargs.extend([
6807            "-sin",
6808            self.sin
6809        ])
6810        return cargs
6811
6812
6813@dataclasses.dataclass
6814class C3dSlice:
6815    """
6816    -slice: Extract slices from an image
6817    
6818    Syntax: `-slice axis position_spec`
6819    
6820    Extracts a slice along the specified axis (x,y or z). The position specifier
6821    **position_spec** can be a single slice or a range of slices. For a single
6822    slice, it can be specified as a number or a percentage. Numbering is
6823    zero-based, i.e, the first slice is slice 0, the last slice is N-1, where N
6824    is the number of slices. For a range, use MATLAB notation first:step:last.
6825    The slice is placed on the stack as an image with size 1 in the last
6826    dimension. You can save the slice as a 2D PNG image.
6827    
6828    c3d input.img -slice x 128 -o myslice.nii.gz
6829    c3d input.img -slice y 50% myslice.nii.gz
6830    c3d input.img -slice z 25% -type uchar -stretch 0 2000 0 255 -o myslice.png
6831    c3d input.img -slice z 0:-1 -oo slice%0d.nii.gz
6832    c3d input.img -slice z 20%:10%:80% -oo slice%0d.nii.gz
6833    
6834    With the new command **c4d**, the **-slice** command can be used to extract
6835    volumes from a 4D image. This can be useful to reformat a 4D NIFTI image as
6836    a 3D multi-component NIFTI image, using the command
6837    
6838    c4d input4d.nii.gz -slice w 0:-1 -omc output3d_multicomp.nii.gz.
6839    """
6840    slice_: str
6841    """-slice: Extract slices from an image
6842    
6843    Syntax: `-slice axis position_spec`
6844    
6845    Extracts a slice along the specified axis (x,y or z). The position specifier
6846    **position_spec** can be a single slice or a range of slices. For a single
6847    slice, it can be specified as a number or a percentage. Numbering is
6848    zero-based, i.e, the first slice is slice 0, the last slice is N-1, where N
6849    is the number of slices. For a range, use MATLAB notation first:step:last.
6850    The slice is placed on the stack as an image with size 1 in the last
6851    dimension. You can save the slice as a 2D PNG image.
6852    
6853    c3d input.img -slice x 128 -o myslice.nii.gz
6854    c3d input.img -slice y 50% myslice.nii.gz
6855    c3d input.img -slice z 25% -type uchar -stretch 0 2000 0 255 -o myslice.png
6856    c3d input.img -slice z 0:-1 -oo slice%0d.nii.gz
6857    c3d input.img -slice z 20%:10%:80% -oo slice%0d.nii.gz
6858    
6859    With the new command **c4d**, the **-slice** command can be used to extract
6860    volumes from a 4D image. This can be useful to reformat a 4D NIFTI image as
6861    a 3D multi-component NIFTI image, using the command
6862    
6863    c4d input4d.nii.gz -slice w 0:-1 -omc output3d_multicomp.nii.gz"""
6864    
6865    def run(
6866        self,
6867        execution: Execution,
6868    ) -> list[str]:
6869        """
6870        Build command line arguments. This method is called by the main command.
6871        
6872        Args:
6873            execution: The execution object.
6874        Returns:
6875            Command line arguments
6876        """
6877        cargs = []
6878        cargs.extend([
6879            "-slice",
6880            self.slice_
6881        ])
6882        return cargs
6883
6884
6885@dataclasses.dataclass
6886class C3dSliceAll:
6887    """
6888    -slice-all: Extract slices from all images on the stack
6889    
6890    Syntax `-slice-all axis position_spec`
6891    
6892    This command behaves identical to the **-slice** command, but all images on
6893    the stack are sliced, and the slices are interleaved. This is useful for
6894    slicing multi-component images. For example, if you read a four-component
6895    image 'test4.nii.gz', you can extract and save the slices as follows:
6896    
6897    c3d test4.nii.gz -slice-all 20%:10%:80% -oomc 4 slice4_%03d.nii.gz.
6898    """
6899    slice_all: str
6900    """-slice-all: Extract slices from all images on the stack
6901    
6902    Syntax `-slice-all axis position_spec`
6903    
6904    This command behaves identical to the **-slice** command, but all images on
6905    the stack are sliced, and the slices are interleaved. This is useful for
6906    slicing multi-component images. For example, if you read a four-component
6907    image 'test4.nii.gz', you can extract and save the slices as follows:
6908    
6909    c3d test4.nii.gz -slice-all 20%:10%:80% -oomc 4 slice4_%03d.nii.gz"""
6910    
6911    def run(
6912        self,
6913        execution: Execution,
6914    ) -> list[str]:
6915        """
6916        Build command line arguments. This method is called by the main command.
6917        
6918        Args:
6919            execution: The execution object.
6920        Returns:
6921            Command line arguments
6922        """
6923        cargs = []
6924        cargs.extend([
6925            "-slice-all",
6926            self.slice_all
6927        ])
6928        return cargs
6929
6930
6931@dataclasses.dataclass
6932class C3dSharpen:
6933    """
6934    -sharpen: Sharpen edges in the image
6935    
6936    Syntax: `-sharpen`
6937    
6938    Applies the Laplacian sharpening filter from ITK, which accentuates the
6939    edges in the image.
6940    
6941    c3d input.nii.gz -sharpen -o output.nii.gz.
6942    """
6943    sharpen: str
6944    """-sharpen: Sharpen edges in the image
6945    
6946    Syntax: `-sharpen`
6947    
6948    Applies the Laplacian sharpening filter from ITK, which accentuates the
6949    edges in the image.
6950    
6951    c3d input.nii.gz -sharpen -o output.nii.gz"""
6952    
6953    def run(
6954        self,
6955        execution: Execution,
6956    ) -> list[str]:
6957        """
6958        Build command line arguments. This method is called by the main command.
6959        
6960        Args:
6961            execution: The execution object.
6962        Returns:
6963            Command line arguments
6964        """
6965        cargs = []
6966        cargs.extend([
6967            "-sharpen",
6968            self.sharpen
6969        ])
6970        return cargs
6971
6972
6973@dataclasses.dataclass
6974class C3dShift:
6975    """
6976    -shift: Shift image intensity by constant
6977    
6978    Syntax: `-shift <constant>`
6979    
6980    Adds the given constant to every voxel.
6981    
6982    c3d img1.img -shift 100 -o img2.img.
6983    """
6984    shift: str
6985    """-shift: Shift image intensity by constant
6986    
6987    Syntax: `-shift <constant>`
6988    
6989    Adds the given constant to every voxel.
6990    
6991    c3d img1.img -shift 100 -o img2.img"""
6992    
6993    def run(
6994        self,
6995        execution: Execution,
6996    ) -> list[str]:
6997        """
6998        Build command line arguments. This method is called by the main command.
6999        
7000        Args:
7001            execution: The execution object.
7002        Returns:
7003            Command line arguments
7004        """
7005        cargs = []
7006        cargs.extend([
7007            "-shift",
7008            self.shift
7009        ])
7010        return cargs
7011
7012
7013@dataclasses.dataclass
7014class C3dSignedDistanceTransform:
7015    """
7016    -sdt, -signed-distance-transform: Signed distance transform of a binary
7017    image
7018    
7019    Syntax: `-sdt`
7020    
7021    Computes the signed distance transform of a binary image. Voxels where the
7022    binary image is non-zero will have negative values and voxels where the
7023    binary image is zero will have negative values. The magnitude of the value
7024    will be the approximate Euclidean distance to the boundary of the object
7025    represented by the binary image.
7026    
7027    c3d binary.img -sdt -o dist.img.
7028    """
7029    signed_distance_transform: str
7030    """-sdt, -signed-distance-transform: Signed distance transform of a binary
7031    image
7032    
7033    Syntax: `-sdt`
7034    
7035    Computes the signed distance transform of a binary image. Voxels where the
7036    binary image is non-zero will have negative values and voxels where the
7037    binary image is zero will have negative values. The magnitude of the value
7038    will be the approximate Euclidean distance to the boundary of the object
7039    represented by the binary image.
7040    
7041    c3d binary.img -sdt -o dist.img"""
7042    
7043    def run(
7044        self,
7045        execution: Execution,
7046    ) -> list[str]:
7047        """
7048        Build command line arguments. This method is called by the main command.
7049        
7050        Args:
7051            execution: The execution object.
7052        Returns:
7053            Command line arguments
7054        """
7055        cargs = []
7056        cargs.extend([
7057            "-signed-distance-transform",
7058            self.signed_distance_transform
7059        ])
7060        return cargs
7061
7062
7063@dataclasses.dataclass
7064class C3dSmooth:
7065    """
7066    -smooth: Gaussian smoothing
7067    
7068    Syntax: `-smooth <sigma_vector> `
7069    
7070    Applies Gaussian smoothing to the image. The parameter vector specifies the
7071    standard deviation of the Gaussian kernel. Also see [Vector Format
7072    Specification][10] below.
7073    
7074    c3d img1.img -smooth 2x1x1vox -o out.img.
7075    """
7076    smooth: str
7077    """-smooth: Gaussian smoothing
7078    
7079    Syntax: `-smooth <sigma_vector> `
7080    
7081    Applies Gaussian smoothing to the image. The parameter vector specifies the
7082    standard deviation of the Gaussian kernel. Also see [Vector Format
7083    Specification][10] below.
7084    
7085    c3d img1.img -smooth 2x1x1vox -o out.img"""
7086    
7087    def run(
7088        self,
7089        execution: Execution,
7090    ) -> list[str]:
7091        """
7092        Build command line arguments. This method is called by the main command.
7093        
7094        Args:
7095            execution: The execution object.
7096        Returns:
7097            Command line arguments
7098        """
7099        cargs = []
7100        cargs.extend([
7101            "-smooth",
7102            self.smooth
7103        ])
7104        return cargs
7105
7106
7107@dataclasses.dataclass
7108class C3dSmoothFast:
7109    """
7110    -smooth-fast: Fast approximate Gaussian smoothing
7111    
7112    Syntax: `-smooth-fast <sigma_vector> `
7113    
7114    Applies Gaussian smoothing to the image using the fast [Deriche recursive
7115    smoothing algorithm][15]. The parameter vector specifies the standard
7116    deviation of the Gaussian kernel. Also see [Vector Format Specification][10]
7117    below.
7118    
7119    c3d img1.img -smooth-fast 20x10x10vox -o out.img.
7120    """
7121    smooth_fast: str
7122    """-smooth-fast: Fast approximate Gaussian smoothing
7123    
7124    Syntax: `-smooth-fast <sigma_vector> `
7125    
7126    Applies Gaussian smoothing to the image using the fast [Deriche recursive
7127    smoothing algorithm][15]. The parameter vector specifies the standard
7128    deviation of the Gaussian kernel. Also see [Vector Format Specification][10]
7129    below.
7130    
7131    c3d img1.img -smooth-fast 20x10x10vox -o out.img"""
7132    
7133    def run(
7134        self,
7135        execution: Execution,
7136    ) -> list[str]:
7137        """
7138        Build command line arguments. This method is called by the main command.
7139        
7140        Args:
7141            execution: The execution object.
7142        Returns:
7143            Command line arguments
7144        """
7145        cargs = []
7146        cargs.extend([
7147            "-smooth-fast",
7148            self.smooth_fast
7149        ])
7150        return cargs
7151
7152
7153@dataclasses.dataclass
7154class C3dSpacing:
7155    """
7156    -spacing: Set voxel spacing
7157    
7158    Syntax: `-spacing <vector> `
7159    
7160    Sets the voxel spacing of the image. This should always be a vector with
7161    positive components. For example, to set the spacing of the image to 1mm
7162    isotropic, use the command below. This command only changes the header of
7163    the image, not its contents.
7164    
7165    c3d img.nii -spacing 1x1x1mm -o out.img.
7166    """
7167    spacing: str
7168    """-spacing: Set voxel spacing
7169    
7170    Syntax: `-spacing <vector> `
7171    
7172    Sets the voxel spacing of the image. This should always be a vector with
7173    positive components. For example, to set the spacing of the image to 1mm
7174    isotropic, use the command below. This command only changes the header of
7175    the image, not its contents.
7176    
7177    c3d img.nii -spacing 1x1x1mm -o out.img"""
7178    
7179    def run(
7180        self,
7181        execution: Execution,
7182    ) -> list[str]:
7183        """
7184        Build command line arguments. This method is called by the main command.
7185        
7186        Args:
7187            execution: The execution object.
7188        Returns:
7189            Command line arguments
7190        """
7191        cargs = []
7192        cargs.extend([
7193            "-spacing",
7194            self.spacing
7195        ])
7196        return cargs
7197
7198
7199@dataclasses.dataclass
7200class C3dSplit:
7201    """
7202    -split: Split multi-label image into binary images
7203    
7204    Syntax: `-split`
7205    
7206    This command takes a multilabel image (one with a small number of discrete
7207    intensity levels), and replaces it with a set of binary images, one for each
7208    of the levels. The images can later be recombined using the **-merge**
7209    command. The labels corresponding to each binary image are remembered by
7210    **convert3d** so that when **-merge** is called, the labels are faithfully
7211    reassigned. The **-merge** command treats each input as a probability image,
7212    and selects at each voxel the label that has highest probability. The
7213    example below smooths each label independently, then recombines using
7214    **-merge**
7215    
7216    c3d multilabel.nii -split -foreach -smooth 3mm -endfor -merge -o
7217    ml_smooth.nii
7218    
7219    Also of note is that the **-split** command will disregard infinite
7220    intensity values. So if you want to apply voting to a subset of the labels,
7221    you can replace labels you do not care about with *inf*, for example, using
7222    the **-thresh** command.
7223    """
7224    split: str
7225    """-split: Split multi-label image into binary images
7226    
7227    Syntax: `-split`
7228    
7229    This command takes a multilabel image (one with a small number of discrete
7230    intensity levels), and replaces it with a set of binary images, one for each
7231    of the levels. The images can later be recombined using the **-merge**
7232    command. The labels corresponding to each binary image are remembered by
7233    **convert3d** so that when **-merge** is called, the labels are faithfully
7234    reassigned. The **-merge** command treats each input as a probability image,
7235    and selects at each voxel the label that has highest probability. The
7236    example below smooths each label independently, then recombines using
7237    **-merge**
7238    
7239    c3d multilabel.nii -split -foreach -smooth 3mm -endfor -merge -o
7240    ml_smooth.nii
7241    
7242    Also of note is that the **-split** command will disregard infinite
7243    intensity values. So if you want to apply voting to a subset of the labels,
7244    you can replace labels you do not care about with *inf*, for example, using
7245    the **-thresh** command."""
7246    
7247    def run(
7248        self,
7249        execution: Execution,
7250    ) -> list[str]:
7251        """
7252        Build command line arguments. This method is called by the main command.
7253        
7254        Args:
7255            execution: The execution object.
7256        Returns:
7257            Command line arguments
7258        """
7259        cargs = []
7260        cargs.extend([
7261            "-split",
7262            self.split
7263        ])
7264        return cargs
7265
7266
7267@dataclasses.dataclass
7268class C3dSqrt:
7269    """
7270    -sqrt: Take square root of image
7271    
7272    Syntax: `-sqrt `
7273    
7274    Computes square root of each voxel in the image.
7275    
7276    c3d input.img -sqrt -o output.img.
7277    """
7278    sqrt: str
7279    """-sqrt: Take square root of image
7280    
7281    Syntax: `-sqrt `
7282    
7283    Computes square root of each voxel in the image.
7284    
7285    c3d input.img -sqrt -o output.img"""
7286    
7287    def run(
7288        self,
7289        execution: Execution,
7290    ) -> list[str]:
7291        """
7292        Build command line arguments. This method is called by the main command.
7293        
7294        Args:
7295            execution: The execution object.
7296        Returns:
7297            Command line arguments
7298        """
7299        cargs = []
7300        cargs.extend([
7301            "-sqrt",
7302            self.sqrt
7303        ])
7304        return cargs
7305
7306
7307@dataclasses.dataclass
7308class C3dStaple:
7309    """
7310    -staple: STAPLE algorithm to combine segmentations
7311    
7312    Syntax: `-staple <intensity_value> `
7313    
7314    Runs the ITK implementation of the STAPLE algorithm ([See Paper][11]).
7315    STAPLE generates an estimate of the 'true' segmentation of a structure given
7316    a set of segmentations by different raters. This command treats all images
7317    on the stack as inputs. Each image is considered to be a segmentation by a
7318    different rater. The parameter *intensity_value* specifies the label in the
7319    segmentation images corresponding to the structure of interest (e.g., the
7320    segmentation image may have value 1 corresponding to the caudate and value 2
7321    corresponding to the hippocampus. To run STAPLE on the hippocampus, pass in
7322    2 as the *intensity_value*). The output of STAPLE is a real-valued image
7323    with voxels between 0 and 1, representing the probability of each voxel
7324    being in the 'true' segmentation. This image can be thresholded to get a
7325    binary consensus segmentation. Additional outputs (estimates of the
7326    sensitivity and specificity of each rater) are printed out if the
7327    **-verbose** command is used before the **-staple** command.
7328    
7329    c3d -verbose rater1.img rater2.img rater3.img -staple 1 -o probmap.img
7330    c3d -verbose rater*.img -staple 1 -threshold 0.5 inf 1 0 -o bin_segm.img.
7331    """
7332    staple: str
7333    """-staple: STAPLE algorithm to combine segmentations
7334    
7335    Syntax: `-staple <intensity_value> `
7336    
7337    Runs the ITK implementation of the STAPLE algorithm ([See Paper][11]).
7338    STAPLE generates an estimate of the 'true' segmentation of a structure given
7339    a set of segmentations by different raters. This command treats all images
7340    on the stack as inputs. Each image is considered to be a segmentation by a
7341    different rater. The parameter *intensity_value* specifies the label in the
7342    segmentation images corresponding to the structure of interest (e.g., the
7343    segmentation image may have value 1 corresponding to the caudate and value 2
7344    corresponding to the hippocampus. To run STAPLE on the hippocampus, pass in
7345    2 as the *intensity_value*). The output of STAPLE is a real-valued image
7346    with voxels between 0 and 1, representing the probability of each voxel
7347    being in the 'true' segmentation. This image can be thresholded to get a
7348    binary consensus segmentation. Additional outputs (estimates of the
7349    sensitivity and specificity of each rater) are printed out if the
7350    **-verbose** command is used before the **-staple** command.
7351    
7352    c3d -verbose rater1.img rater2.img rater3.img -staple 1 -o probmap.img
7353    c3d -verbose rater*.img -staple 1 -threshold 0.5 inf 1 0 -o bin_segm.img"""
7354    
7355    def run(
7356        self,
7357        execution: Execution,
7358    ) -> list[str]:
7359        """
7360        Build command line arguments. This method is called by the main command.
7361        
7362        Args:
7363            execution: The execution object.
7364        Returns:
7365            Command line arguments
7366        """
7367        cargs = []
7368        cargs.extend([
7369            "-staple",
7370            self.staple
7371        ])
7372        return cargs
7373
7374
7375@dataclasses.dataclass
7376class C3dStructureTensorEigenvalues:
7377    """
7378    -steig, -structure-tensor-eigenvalues: Compute eigenvalues of the structure
7379    tensor
7380    
7381    Syntax `-steig <scale> <radius>`
7382    
7383    Computes the Hessian matrix at every pixel of an image and the eigenvalues
7384    of the Hessian. Images of the eigenvalues (sorted by value) are placed on
7385    the stack. These images are useful as texture features. See also the
7386    '''-steig''' command. The scale determines the amount of Gaussian smoothing
7387    applied for computing the partial derivatives in the Hessian, and is in
7388    physical (mm) units.
7389    
7390    c3d myimage.nii -hesseig 2.0 -oo eig%02d.nii.gz.
7391    """
7392    structure_tensor_eigenvalues: str
7393    """-steig, -structure-tensor-eigenvalues: Compute eigenvalues of the
7394    structure tensor
7395    
7396    Syntax `-steig <scale> <radius>`
7397    
7398    Computes the Hessian matrix at every pixel of an image and the eigenvalues
7399    of the Hessian. Images of the eigenvalues (sorted by value) are placed on
7400    the stack. These images are useful as texture features. See also the
7401    '''-steig''' command. The scale determines the amount of Gaussian smoothing
7402    applied for computing the partial derivatives in the Hessian, and is in
7403    physical (mm) units.
7404    
7405    c3d myimage.nii -hesseig 2.0 -oo eig%02d.nii.gz"""
7406    
7407    def run(
7408        self,
7409        execution: Execution,
7410    ) -> list[str]:
7411        """
7412        Build command line arguments. This method is called by the main command.
7413        
7414        Args:
7415            execution: The execution object.
7416        Returns:
7417            Command line arguments
7418        """
7419        cargs = []
7420        cargs.extend([
7421            "-steig",
7422            self.structure_tensor_eigenvalues
7423        ])
7424        return cargs
7425
7426
7427@dataclasses.dataclass
7428class C3dSpm:
7429    """
7430    -spm, -nospm: SPM compatibility in Analyze output
7431    
7432    Syntax: `-spm` or `-nospm `
7433    
7434    These options specify whether use the SPM extension to the Analyze
7435    (.hdr,.img) format. When this option is on, the origin field stored by SPM
7436    in the Analyze header will be correctly interpreted. When saving analyze
7437    files, the origin will be set correctly. The default is equivalent to the
7438    **-nospm** option. Best to avoid this issue altogether by using NIFTI and
7439    SPM5 or later.
7440    
7441    c3d -spm in.hdr out.img.gz.
7442    """
7443    spm: str
7444    """-spm, -nospm: SPM compatibility in Analyze output
7445    
7446    Syntax: `-spm` or `-nospm `
7447    
7448    These options specify whether use the SPM extension to the Analyze
7449    (.hdr,.img) format. When this option is on, the origin field stored by SPM
7450    in the Analyze header will be correctly interpreted. When saving analyze
7451    files, the origin will be set correctly. The default is equivalent to the
7452    **-nospm** option. Best to avoid this issue altogether by using NIFTI and
7453    SPM5 or later.
7454    
7455    c3d -spm in.hdr out.img.gz"""
7456    
7457    def run(
7458        self,
7459        execution: Execution,
7460    ) -> list[str]:
7461        """
7462        Build command line arguments. This method is called by the main command.
7463        
7464        Args:
7465            execution: The execution object.
7466        Returns:
7467            Command line arguments
7468        """
7469        cargs = []
7470        cargs.extend([
7471            "-spm",
7472            self.spm
7473        ])
7474        return cargs
7475
7476
7477@dataclasses.dataclass
7478class C3dSubtract:
7479    """
7480    No description found.
7481    """
7482    subtract: str
7483    """No description found."""
7484    
7485    def run(
7486        self,
7487        execution: Execution,
7488    ) -> list[str]:
7489        """
7490        Build command line arguments. This method is called by the main command.
7491        
7492        Args:
7493            execution: The execution object.
7494        Returns:
7495            Command line arguments
7496        """
7497        cargs = []
7498        cargs.extend([
7499            "-subtract",
7500            self.subtract
7501        ])
7502        return cargs
7503
7504
7505@dataclasses.dataclass
7506class C3dSupervoxel:
7507    """
7508    No description found.
7509    """
7510    supervoxel: str
7511    """No description found."""
7512    
7513    def run(
7514        self,
7515        execution: Execution,
7516    ) -> list[str]:
7517        """
7518        Build command line arguments. This method is called by the main command.
7519        
7520        Args:
7521            execution: The execution object.
7522        Returns:
7523            Command line arguments
7524        """
7525        cargs = []
7526        cargs.extend([
7527            "-supervoxel",
7528            self.supervoxel
7529        ])
7530        return cargs
7531
7532
7533@dataclasses.dataclass
7534class C3dStretch:
7535    """
7536    -stretch: Stretch image intensities linearly
7537    
7538    Syntax: `-stretch <u1 u2 v1 v2> `
7539    
7540    Stretches the intensities in the image linearly, such that u1 maps to v1 and
7541    u2 maps to v2. The linear transformation is applied to all intensities in
7542    the image, whether inside the range or not. For example, to map a floating
7543    point image with intensities in interval (0,1) to the full range of an
7544    unsigned short image, use
7545    
7546    c3d input.img -stretch 0.0 1.0 0 65535 -type ushort -o output.img.
7547    """
7548    stretch: str
7549    """-stretch: Stretch image intensities linearly
7550    
7551    Syntax: `-stretch <u1 u2 v1 v2> `
7552    
7553    Stretches the intensities in the image linearly, such that u1 maps to v1 and
7554    u2 maps to v2. The linear transformation is applied to all intensities in
7555    the image, whether inside the range or not. For example, to map a floating
7556    point image with intensities in interval (0,1) to the full range of an
7557    unsigned short image, use
7558    
7559    c3d input.img -stretch 0.0 1.0 0 65535 -type ushort -o output.img"""
7560    
7561    def run(
7562        self,
7563        execution: Execution,
7564    ) -> list[str]:
7565        """
7566        Build command line arguments. This method is called by the main command.
7567        
7568        Args:
7569            execution: The execution object.
7570        Returns:
7571            Command line arguments
7572        """
7573        cargs = []
7574        cargs.extend([
7575            "-stretch",
7576            self.stretch
7577        ])
7578        return cargs
7579
7580
7581@dataclasses.dataclass
7582class C3dSwapdim:
7583    """
7584    -swapdim: Reorder the coordinate axes of an image
7585    
7586    Syntax `-swapdim <code>`
7587    
7588    This command reorders the image axes (columns, rows, slices) to achieve a
7589    desired transformation between voxel space and physical space. The image
7590    remains exactly the same in physical space, but the encoding of the voxels
7591    in memory and on disk is changed to obtain the desired transformation. The
7592    transformation is specified as a three-letter 'RAI' code, as in the
7593    '''-orient''' command.
7594    
7595    c3d img.nii -swapdim ASL -info -o out.nii
7596    
7597    
7598    ### Commands: Image Processing
7599    
7600    The following commands invoke an action that is applied to images. Unary
7601    commands apply the action to the last image on the stack, binary commands
7602    apply to the last two images and so on. Commands are affected by options,
7603    which are listed separately.
7604    """
7605    swapdim: str
7606    """-swapdim: Reorder the coordinate axes of an image
7607    
7608    Syntax `-swapdim <code>`
7609    
7610    This command reorders the image axes (columns, rows, slices) to achieve a
7611    desired transformation between voxel space and physical space. The image
7612    remains exactly the same in physical space, but the encoding of the voxels
7613    in memory and on disk is changed to obtain the desired transformation. The
7614    transformation is specified as a three-letter 'RAI' code, as in the
7615    '''-orient''' command.
7616    
7617    c3d img.nii -swapdim ASL -info -o out.nii
7618    
7619    
7620    ### Commands: Image Processing
7621    
7622    The following commands invoke an action that is applied to images. Unary
7623    commands apply the action to the last image on the stack, binary commands
7624    apply to the last two images and so on. Commands are affected by options,
7625    which are listed separately."""
7626    
7627    def run(
7628        self,
7629        execution: Execution,
7630    ) -> list[str]:
7631        """
7632        Build command line arguments. This method is called by the main command.
7633        
7634        Args:
7635            execution: The execution object.
7636        Returns:
7637            Command line arguments
7638        """
7639        cargs = []
7640        cargs.extend([
7641            "-swapdim",
7642            self.swapdim
7643        ])
7644        return cargs
7645
7646
7647@dataclasses.dataclass
7648class C3dTestImage:
7649    """
7650    -test-image, -test-probe: Test condition
7651    
7652    Syntax: `-test-image [tolerance]` and `-test-probe <vector> <value>
7653    [tolerance]`
7654    
7655    These advanced commands (with more to come in the future) are primarily
7656    meant to allow testing of **c3d**. However, they can also be used for flow
7657    control in shell scripts (e.g., **bash** shell). The commands check a
7658    certain aspect of the **c3d** state and cause the program to exit with
7659    either return code 0 if the test succeeded or a non-zero return code if the
7660    test failed.
7661    
7662    **-test-image** tests if the last two images on the stack are identical
7663    (both in terms of data and header). Returns 0 if the images are identical.
7664    The optional tolerance parameter has default value 1e-8.
7665    
7666    c3d input1.img input2.img -test-image
7667    
7668    **-test-probe** is similar to the **-probe** command. It tests if the value
7669    of the last image on the stack at the position given by **vector** is equal
7670    to the **test_value**. An optional tolerance value may be specified, the
7671    default is 1e-8.
7672    
7673    c3d input1.img -test-probe 40x40x20vox 1.0 1e-6.
7674    """
7675    test_image: str
7676    """-test-image, -test-probe: Test condition
7677    
7678    Syntax: `-test-image [tolerance]` and `-test-probe <vector> <value>
7679    [tolerance]`
7680    
7681    These advanced commands (with more to come in the future) are primarily
7682    meant to allow testing of **c3d**. However, they can also be used for flow
7683    control in shell scripts (e.g., **bash** shell). The commands check a
7684    certain aspect of the **c3d** state and cause the program to exit with
7685    either return code 0 if the test succeeded or a non-zero return code if the
7686    test failed.
7687    
7688    **-test-image** tests if the last two images on the stack are identical
7689    (both in terms of data and header). Returns 0 if the images are identical.
7690    The optional tolerance parameter has default value 1e-8.
7691    
7692    c3d input1.img input2.img -test-image
7693    
7694    **-test-probe** is similar to the **-probe** command. It tests if the value
7695    of the last image on the stack at the position given by **vector** is equal
7696    to the **test_value**. An optional tolerance value may be specified, the
7697    default is 1e-8.
7698    
7699    c3d input1.img -test-probe 40x40x20vox 1.0 1e-6"""
7700    
7701    def run(
7702        self,
7703        execution: Execution,
7704    ) -> list[str]:
7705        """
7706        Build command line arguments. This method is called by the main command.
7707        
7708        Args:
7709            execution: The execution object.
7710        Returns:
7711            Command line arguments
7712        """
7713        cargs = []
7714        cargs.extend([
7715            "-test-image",
7716            self.test_image
7717        ])
7718        return cargs
7719
7720
7721@dataclasses.dataclass
7722class C3dTestProbe:
7723    """
7724    -test-image, -test-probe: Test condition
7725    
7726    Syntax: `-test-image [tolerance]` and `-test-probe <vector> <value>
7727    [tolerance]`
7728    
7729    These advanced commands (with more to come in the future) are primarily
7730    meant to allow testing of **c3d**. However, they can also be used for flow
7731    control in shell scripts (e.g., **bash** shell). The commands check a
7732    certain aspect of the **c3d** state and cause the program to exit with
7733    either return code 0 if the test succeeded or a non-zero return code if the
7734    test failed.
7735    
7736    **-test-image** tests if the last two images on the stack are identical
7737    (both in terms of data and header). Returns 0 if the images are identical.
7738    The optional tolerance parameter has default value 1e-8.
7739    
7740    c3d input1.img input2.img -test-image
7741    
7742    **-test-probe** is similar to the **-probe** command. It tests if the value
7743    of the last image on the stack at the position given by **vector** is equal
7744    to the **test_value**. An optional tolerance value may be specified, the
7745    default is 1e-8.
7746    
7747    c3d input1.img -test-probe 40x40x20vox 1.0 1e-6.
7748    """
7749    test_probe: str
7750    """-test-image, -test-probe: Test condition
7751    
7752    Syntax: `-test-image [tolerance]` and `-test-probe <vector> <value>
7753    [tolerance]`
7754    
7755    These advanced commands (with more to come in the future) are primarily
7756    meant to allow testing of **c3d**. However, they can also be used for flow
7757    control in shell scripts (e.g., **bash** shell). The commands check a
7758    certain aspect of the **c3d** state and cause the program to exit with
7759    either return code 0 if the test succeeded or a non-zero return code if the
7760    test failed.
7761    
7762    **-test-image** tests if the last two images on the stack are identical
7763    (both in terms of data and header). Returns 0 if the images are identical.
7764    The optional tolerance parameter has default value 1e-8.
7765    
7766    c3d input1.img input2.img -test-image
7767    
7768    **-test-probe** is similar to the **-probe** command. It tests if the value
7769    of the last image on the stack at the position given by **vector** is equal
7770    to the **test_value**. An optional tolerance value may be specified, the
7771    default is 1e-8.
7772    
7773    c3d input1.img -test-probe 40x40x20vox 1.0 1e-6"""
7774    
7775    def run(
7776        self,
7777        execution: Execution,
7778    ) -> list[str]:
7779        """
7780        Build command line arguments. This method is called by the main command.
7781        
7782        Args:
7783            execution: The execution object.
7784        Returns:
7785            Command line arguments
7786        """
7787        cargs = []
7788        cargs.extend([
7789            "-test-probe",
7790            self.test_probe
7791        ])
7792        return cargs
7793
7794
7795@dataclasses.dataclass
7796class C3dThreshold:
7797    """
7798    -thresh, -threshold: Binary thresholding
7799    
7800    Syntax: `-thresh <u1 u2 vIn vOut> `
7801    
7802    Thresholds the image, setting voxels whose intensity is in the range [u1,u2]
7803    to vIn and all other voxels to vOut. Values *u1* and *u2* are intensity
7804    specifications (see below). This means that you can supply values **inf**
7805    and **-inf** for u1 and u2 to construct a one-sided threshold. You can also
7806    specify *u1* and *u2* as percentiles.
7807    c3d in.img -threshold -inf 128 1 0 -o out.img
7808    c3d in.img -threshold 64 128 1 0 -o out.img
7809    c3d in.img -threshold 20% 40% 1 0 -o out.img.
7810    """
7811    threshold: str
7812    """-thresh, -threshold: Binary thresholding
7813    
7814    Syntax: `-thresh <u1 u2 vIn vOut> `
7815    
7816    Thresholds the image, setting voxels whose intensity is in the range [u1,u2]
7817    to vIn and all other voxels to vOut. Values *u1* and *u2* are intensity
7818    specifications (see below). This means that you can supply values **inf**
7819    and **-inf** for u1 and u2 to construct a one-sided threshold. You can also
7820    specify *u1* and *u2* as percentiles.
7821    c3d in.img -threshold -inf 128 1 0 -o out.img
7822    c3d in.img -threshold 64 128 1 0 -o out.img
7823    c3d in.img -threshold 20% 40% 1 0 -o out.img"""
7824    
7825    def run(
7826        self,
7827        execution: Execution,
7828    ) -> list[str]:
7829        """
7830        Build command line arguments. This method is called by the main command.
7831        
7832        Args:
7833            execution: The execution object.
7834        Returns:
7835            Command line arguments
7836        """
7837        cargs = []
7838        cargs.extend([
7839            "-threshold",
7840            self.threshold
7841        ])
7842        return cargs
7843
7844
7845@dataclasses.dataclass
7846class C3dTile:
7847    """
7848    -tile: Tile and stack multiple images into one
7849    
7850    Syntax: `-tile <tile_spec>`
7851    
7852    Tiles multiple images into a single image -- including stacking slices into
7853    a 3D volume. The command takes all images on the stack and produces a single
7854    tiled image. The **tile_spec** parameter can either specify a coordinate
7855    axis (x, y, or z) along which to tile the images, or a layout vector (e.g.,
7856    **4x4**) which specifies the tiling along each coordinate. Passing 0 for the
7857    last value in the layout vector determines the value based on the number of
7858    images currently loaded. For example, to create a 3D volume from a set of
7859    slices, we use
7860    
7861    c3d slices*.png -tile z -o volume.nii.gz
7862    
7863    And to arrange the same 2D slices into a 2D montage of 4 images per row, we
7864    would use the **c2d** command as follows:
7865    
7866    c2d slices*.png -tile 4x0 -type uchar -o montage.png.
7867    """
7868    tile: str
7869    """-tile: Tile and stack multiple images into one
7870    
7871    Syntax: `-tile <tile_spec>`
7872    
7873    Tiles multiple images into a single image -- including stacking slices into
7874    a 3D volume. The command takes all images on the stack and produces a single
7875    tiled image. The **tile_spec** parameter can either specify a coordinate
7876    axis (x, y, or z) along which to tile the images, or a layout vector (e.g.,
7877    **4x4**) which specifies the tiling along each coordinate. Passing 0 for the
7878    last value in the layout vector determines the value based on the number of
7879    images currently loaded. For example, to create a 3D volume from a set of
7880    slices, we use
7881    
7882    c3d slices*.png -tile z -o volume.nii.gz
7883    
7884    And to arrange the same 2D slices into a 2D montage of 4 images per row, we
7885    would use the **c2d** command as follows:
7886    
7887    c2d slices*.png -tile 4x0 -type uchar -o montage.png"""
7888    
7889    def run(
7890        self,
7891        execution: Execution,
7892    ) -> list[str]:
7893        """
7894        Build command line arguments. This method is called by the main command.
7895        
7896        Args:
7897            execution: The execution object.
7898        Returns:
7899            Command line arguments
7900        """
7901        cargs = []
7902        cargs.extend([
7903            "-tile",
7904            self.tile
7905        ])
7906        return cargs
7907
7908
7909@dataclasses.dataclass
7910class C3dTrim:
7911    """
7912    -trim: Trim background region of image
7913    
7914    Syntax: `-trim <margin_vector>`
7915    
7916    Use this command to trim background in an image. When most of the image is
7917    filled by background, this command will find the smallest rectangular region
7918    that contains all of the non-background voxels in the image. I will then
7919    expand this region by the margin of the size specified, and return the
7920    resulting region as the new image. For example, this command will trim an
7921    image, leaving a 5-voxel margin of background values on all sides
7922    
7923    c3d in.img -trim 5vox -o out.img.
7924    """
7925    trim: str
7926    """-trim: Trim background region of image
7927    
7928    Syntax: `-trim <margin_vector>`
7929    
7930    Use this command to trim background in an image. When most of the image is
7931    filled by background, this command will find the smallest rectangular region
7932    that contains all of the non-background voxels in the image. I will then
7933    expand this region by the margin of the size specified, and return the
7934    resulting region as the new image. For example, this command will trim an
7935    image, leaving a 5-voxel margin of background values on all sides
7936    
7937    c3d in.img -trim 5vox -o out.img"""
7938    
7939    def run(
7940        self,
7941        execution: Execution,
7942    ) -> list[str]:
7943        """
7944        Build command line arguments. This method is called by the main command.
7945        
7946        Args:
7947            execution: The execution object.
7948        Returns:
7949            Command line arguments
7950        """
7951        cargs = []
7952        cargs.extend([
7953            "-trim",
7954            self.trim
7955        ])
7956        return cargs
7957
7958
7959@dataclasses.dataclass
7960class C3dTrimToSize:
7961    """
7962    -trim-to-size: Trim image to given size
7963    
7964    Syntax: `-trim-to-size <size_vector>`
7965    
7966    Like **-trim**, this command trims the background in an image. However,
7967    instead of **-trim**, you specify the target size of the output region. The
7968    actual region may be smaller if the specified region falls outside the
7969    boundaries of the input image. For example, if you want a 64x64x128 image
7970    containing all the foreground pixels in your image, call
7971    
7972    c3d in.img -trim-to-size 64x64x128vox -o out.img.
7973    """
7974    trim_to_size: str
7975    """-trim-to-size: Trim image to given size
7976    
7977    Syntax: `-trim-to-size <size_vector>`
7978    
7979    Like **-trim**, this command trims the background in an image. However,
7980    instead of **-trim**, you specify the target size of the output region. The
7981    actual region may be smaller if the specified region falls outside the
7982    boundaries of the input image. For example, if you want a 64x64x128 image
7983    containing all the foreground pixels in your image, call
7984    
7985    c3d in.img -trim-to-size 64x64x128vox -o out.img"""
7986    
7987    def run(
7988        self,
7989        execution: Execution,
7990    ) -> list[str]:
7991        """
7992        Build command line arguments. This method is called by the main command.
7993        
7994        Args:
7995            execution: The execution object.
7996        Returns:
7997            Command line arguments
7998        """
7999        cargs = []
8000        cargs.extend([
8001            "-trim-to-size",
8002            self.trim_to_size
8003        ])
8004        return cargs
8005
8006
8007@dataclasses.dataclass
8008class C3dType:
8009    """
8010    -type: Specify pixel type for image output
8011    
8012    Syntax: `-type < char | uchar | short | ushort | int | uint | float | double
8013    > `
8014    
8015    Specifies the pixel type for the output image. By default, images are
8016    written in floating point (**float**) format. The type does not affect how
8017    images are processed, only how they are saved.
8018    
8019    c3d image1.img -type short image2.img
8020    
8021    Some images require data in certain types. For example, to save PNG images,
8022    uchar or ushort type must be specified.
8023    """
8024    type_: str
8025    """-type: Specify pixel type for image output
8026    
8027    Syntax: `-type < char | uchar | short | ushort | int | uint | float | double
8028    > `
8029    
8030    Specifies the pixel type for the output image. By default, images are
8031    written in floating point (**float**) format. The type does not affect how
8032    images are processed, only how they are saved.
8033    
8034    c3d image1.img -type short image2.img
8035    
8036    Some images require data in certain types. For example, to save PNG images,
8037    uchar or ushort type must be specified."""
8038    
8039    def run(
8040        self,
8041        execution: Execution,
8042    ) -> list[str]:
8043        """
8044        Build command line arguments. This method is called by the main command.
8045        
8046        Args:
8047            execution: The execution object.
8048        Returns:
8049            Command line arguments
8050        """
8051        cargs = []
8052        cargs.extend([
8053            "-type",
8054            self.type_
8055        ])
8056        return cargs
8057
8058
8059@dataclasses.dataclass
8060class C3dVerbose:
8061    """
8062    -verbose: Enable verbose output of commands
8063    
8064    Syntax: `-verbose`
8065    
8066    Commands entered after the **-verbose** command will print debugging
8067    information. This can be turned off with **-noverbose**.
8068    
8069    ### Parameter Specifications.
8070    """
8071    verbose: str
8072    """-verbose: Enable verbose output of commands
8073    
8074    Syntax: `-verbose`
8075    
8076    Commands entered after the **-verbose** command will print debugging
8077    information. This can be turned off with **-noverbose**.
8078    
8079    ### Parameter Specifications"""
8080    
8081    def run(
8082        self,
8083        execution: Execution,
8084    ) -> list[str]:
8085        """
8086        Build command line arguments. This method is called by the main command.
8087        
8088        Args:
8089            execution: The execution object.
8090        Returns:
8091            Command line arguments
8092        """
8093        cargs = []
8094        cargs.extend([
8095            "-verbose",
8096            self.verbose
8097        ])
8098        return cargs
8099
8100
8101@dataclasses.dataclass
8102class C3dNoverbose:
8103    """
8104    No description found.
8105    """
8106    noverbose: str
8107    """No description found."""
8108    
8109    def run(
8110        self,
8111        execution: Execution,
8112    ) -> list[str]:
8113        """
8114        Build command line arguments. This method is called by the main command.
8115        
8116        Args:
8117            execution: The execution object.
8118        Returns:
8119            Command line arguments
8120        """
8121        cargs = []
8122        cargs.extend([
8123            "-noverbose",
8124            self.noverbose
8125        ])
8126        return cargs
8127
8128
8129@dataclasses.dataclass
8130class C3dVersion:
8131    """
8132    No description found.
8133    """
8134    version: str
8135    """No description found."""
8136    
8137    def run(
8138        self,
8139        execution: Execution,
8140    ) -> list[str]:
8141        """
8142        Build command line arguments. This method is called by the main command.
8143        
8144        Args:
8145            execution: The execution object.
8146        Returns:
8147            Command line arguments
8148        """
8149        cargs = []
8150        cargs.extend([
8151            "-version",
8152            self.version
8153        ])
8154        return cargs
8155
8156
8157@dataclasses.dataclass
8158class C3dVote:
8159    """
8160    -vote: Vote among images on the stack
8161    
8162    Syntax: `-vote `
8163    
8164    This command takes all images on the stack as arguments and at each voxel
8165    *(i,j,k)* returns the index of the image for which the image value at
8166    *(i,j,k)* is the greatest. This is most useful when combining probability
8167    maps into a single label image. If images prob1.img, prob2.img, etc. give
8168    the probability of label 1, 2, etc. over the image domain, the **-vote**
8169    command will return the most probable label at each voxel.
8170    
8171    c3d prob1.img prob2.img prob3.img -vote -type uchar -o label.img
8172    
8173    The value assigned to each image is based on its position from the bottom of
8174    the stack, with zero indicating bottom-most image. In the example above, the
8175    output image has values 0 for voxels where prob1.img is highest, 1 for
8176    prob2.img and 2 for prob3.img. Also see the related commands **-split** and
8177    **-merge**.
8178    """
8179    vote: str
8180    """-vote: Vote among images on the stack
8181    
8182    Syntax: `-vote `
8183    
8184    This command takes all images on the stack as arguments and at each voxel
8185    *(i,j,k)* returns the index of the image for which the image value at
8186    *(i,j,k)* is the greatest. This is most useful when combining probability
8187    maps into a single label image. If images prob1.img, prob2.img, etc. give
8188    the probability of label 1, 2, etc. over the image domain, the **-vote**
8189    command will return the most probable label at each voxel.
8190    
8191    c3d prob1.img prob2.img prob3.img -vote -type uchar -o label.img
8192    
8193    The value assigned to each image is based on its position from the bottom of
8194    the stack, with zero indicating bottom-most image. In the example above, the
8195    output image has values 0 for voxels where prob1.img is highest, 1 for
8196    prob2.img and 2 for prob3.img. Also see the related commands **-split** and
8197    **-merge**."""
8198    
8199    def run(
8200        self,
8201        execution: Execution,
8202    ) -> list[str]:
8203        """
8204        Build command line arguments. This method is called by the main command.
8205        
8206        Args:
8207            execution: The execution object.
8208        Returns:
8209            Command line arguments
8210        """
8211        cargs = []
8212        cargs.extend([
8213            "-vote",
8214            self.vote
8215        ])
8216        return cargs
8217
8218
8219@dataclasses.dataclass
8220class C3dVoteMrf:
8221    """
8222    -vote-mrf: Vote with Markov Random Field regularlization
8223    
8224    Syntax: `-vote-mrf <mode> <lambda>`
8225    
8226    This command is similar to **-vote** but it performs regularlization using
8227    the Markov Random Field (MRF). This form of regularization penalizes the
8228    total surface area of the segments in the output. It results in more
8229    contiguous segments.
8230    
8231    The command takes all the images on the stack and assumes that they are
8232    likelihood images corresponding to labels 1, 2, ... N. This means that voxel
8233    **x** in image **k** holds the probability that voxel **x** has label **k**.
8234    Likelihood images must be between 0 and 1. Any values outside of the range
8235    are interpreted as the voxel being excluded from the voting. These voxels
8236    will be assigned label 0 in the output.
8237    
8238    The problem is encoded in the form of energy minimization, consisting of a
8239    data term and a regularization term. The data term encodes the cost
8240    (penalty) associated with assigning the voxel **x** the label **k**. The
8241    parameter **mode** describes how likelihood images are mapped to the cost.
8242    
8243    * `VOTES_AGAINST` or `VA`. This mode is useful when the command is being
8244    used to combine several multi-label segmentations into a single one. Each
8245    likelihood image is assumed to be the proportion of segmentations that
8246    assign label *k* to voxel *x*. The data term equals to the error associated
8247    to assining the voxel *k* label *x*. This error is calculated as the sum of
8248    the likelihoods for all labels at *x* minus the likelihood for *k* at *x*.
8249    Note that the likelihoods do not have to add up to one, which may be
8250    interpreted as missing data for some voxels.
8251    
8252    * `LOG_LIKELIHOOD` or `LL`. The cost for label *k* at voxel *x* is the
8253    logarithm of the k-th likelihood image at *x*. This will assign infinite
8254    cost when the likelihood is zero.
8255    
8256    The regularlization term is encoded as **lambda** times the total number of
8257    neighboring voxels inside the mask (non-excluded region of the image) that
8258    have different labels.
8259    
8260    The optmization problem is solved using the Alpha-Expansion graph cut
8261    algorithm. Users of this functionality should cite the following papers.
8262    
8263    1. Yuri Boykov, Olga Veksler, Ramin Zabih, *Efficient Approximate Energy
8264    Minimization via Graph Cuts*, IEEE transactions on PAMI, vol. 20, no. 12, p.
8265    1222-1239, 2001.
8266    
8267    2. Vladimir Kolmogorov and Ramin Zabih, *What Energy Functions can be
8268    Minimized via Graph Cuts?*, IEEE transactions on PAMI, vol. 26, no. 2, p.
8269    147-159, 2004.
8270    
8271    3. Yuri Boykov and Vladimir Kolmogorov, *An Experimental Comparison of
8272    Min-Cut/Max-Flow Algorithms for Energy Minimization in Vision*, IEEE
8273    transactions on PAMI, vol. 26, no. 9, p. 1124-1137, 2004.
8274    
8275    As noted in the open source implementation of the graph cuts algorithms
8276    distributed under the General Public License, "This software can be used
8277    only for research purposes, you should cite the aforementioned paper in any
8278    resulting publication. If you wish to use this software (or the algorithms
8279    described in the aforementioned paper) for commercial purposes, you should
8280    be aware that there is a US patent: R. Zabih, Y. Boykov, O. Veksler, *System
8281    and method for fast approximate energy minimization via graph cuts*, United
8282    Stated Patent 6,744,923, June 1, 2004.
8283    
8284    The example below illustrates applying **-vote-mrf** with a user-specified
8285    mask. Voxels outside of the mask are first remapped to NaN (not a number)
8286    and thus excluded from the MRF optimization and given 0 label.
8287    
8288    c3d lhood01.nii lhood02.nii lhood03.nii mask.nii -popas M \
8289    -foreach -push M -replace 0 NaN -times -endfor \
8290    -vote-mrf VA 0.2 -o result.nii.
8291    """
8292    vote_mrf: str
8293    """-vote-mrf: Vote with Markov Random Field regularlization
8294    
8295    Syntax: `-vote-mrf <mode> <lambda>`
8296    
8297    This command is similar to **-vote** but it performs regularlization using
8298    the Markov Random Field (MRF). This form of regularization penalizes the
8299    total surface area of the segments in the output. It results in more
8300    contiguous segments.
8301    
8302    The command takes all the images on the stack and assumes that they are
8303    likelihood images corresponding to labels 1, 2, ... N. This means that voxel
8304    **x** in image **k** holds the probability that voxel **x** has label **k**.
8305    Likelihood images must be between 0 and 1. Any values outside of the range
8306    are interpreted as the voxel being excluded from the voting. These voxels
8307    will be assigned label 0 in the output.
8308    
8309    The problem is encoded in the form of energy minimization, consisting of a
8310    data term and a regularization term. The data term encodes the cost
8311    (penalty) associated with assigning the voxel **x** the label **k**. The
8312    parameter **mode** describes how likelihood images are mapped to the cost.
8313    
8314    * `VOTES_AGAINST` or `VA`. This mode is useful when the command is being
8315    used to combine several multi-label segmentations into a single one. Each
8316    likelihood image is assumed to be the proportion of segmentations that
8317    assign label *k* to voxel *x*. The data term equals to the error associated
8318    to assining the voxel *k* label *x*. This error is calculated as the sum of
8319    the likelihoods for all labels at *x* minus the likelihood for *k* at *x*.
8320    Note that the likelihoods do not have to add up to one, which may be
8321    interpreted as missing data for some voxels.
8322    
8323    * `LOG_LIKELIHOOD` or `LL`. The cost for label *k* at voxel *x* is the
8324    logarithm of the k-th likelihood image at *x*. This will assign infinite
8325    cost when the likelihood is zero.
8326    
8327    The regularlization term is encoded as **lambda** times the total number of
8328    neighboring voxels inside the mask (non-excluded region of the image) that
8329    have different labels.
8330    
8331    The optmization problem is solved using the Alpha-Expansion graph cut
8332    algorithm. Users of this functionality should cite the following papers.
8333    
8334    1. Yuri Boykov, Olga Veksler, Ramin Zabih, *Efficient Approximate Energy
8335    Minimization via Graph Cuts*, IEEE transactions on PAMI, vol. 20, no. 12, p.
8336    1222-1239, 2001.
8337    
8338    2. Vladimir Kolmogorov and Ramin Zabih, *What Energy Functions can be
8339    Minimized via Graph Cuts?*, IEEE transactions on PAMI, vol. 26, no. 2, p.
8340    147-159, 2004.
8341    
8342    3. Yuri Boykov and Vladimir Kolmogorov, *An Experimental Comparison of
8343    Min-Cut/Max-Flow Algorithms for Energy Minimization in Vision*, IEEE
8344    transactions on PAMI, vol. 26, no. 9, p. 1124-1137, 2004.
8345    
8346    As noted in the open source implementation of the graph cuts algorithms
8347    distributed under the General Public License, "This software can be used
8348    only for research purposes, you should cite the aforementioned paper in any
8349    resulting publication. If you wish to use this software (or the algorithms
8350    described in the aforementioned paper) for commercial purposes, you should
8351    be aware that there is a US patent: R. Zabih, Y. Boykov, O. Veksler, *System
8352    and method for fast approximate energy minimization via graph cuts*, United
8353    Stated Patent 6,744,923, June 1, 2004.
8354    
8355    The example below illustrates applying **-vote-mrf** with a user-specified
8356    mask. Voxels outside of the mask are first remapped to NaN (not a number)
8357    and thus excluded from the MRF optimization and given 0 label.
8358    
8359    c3d lhood01.nii lhood02.nii lhood03.nii mask.nii -popas M \
8360    -foreach -push M -replace 0 NaN -times -endfor \
8361    -vote-mrf VA 0.2 -o result.nii"""
8362    
8363    def run(
8364        self,
8365        execution: Execution,
8366    ) -> list[str]:
8367        """
8368        Build command line arguments. This method is called by the main command.
8369        
8370        Args:
8371            execution: The execution object.
8372        Returns:
8373            Command line arguments
8374        """
8375        cargs = []
8376        cargs.extend([
8377            "-vote-mrf",
8378            self.vote_mrf
8379        ])
8380        return cargs
8381
8382
8383@dataclasses.dataclass
8384class C3dVoteLabel:
8385    """
8386    No description found.
8387    """
8388    vote_label: str
8389    """No description found."""
8390    
8391    def run(
8392        self,
8393        execution: Execution,
8394    ) -> list[str]:
8395        """
8396        Build command line arguments. This method is called by the main command.
8397        
8398        Args:
8399            execution: The execution object.
8400        Returns:
8401            Command line arguments
8402        """
8403        cargs = []
8404        cargs.extend([
8405            "-vote-label",
8406            self.vote_label
8407        ])
8408        return cargs
8409
8410
8411@dataclasses.dataclass
8412class C3dVoxelSum:
8413    """
8414    -voxel-sum: Print sum of all voxel intensities
8415    
8416    Syntax: `-voxel-sum `
8417    
8418    Print the sum of all voxels in the image.
8419    
8420    $ c3d image.img -voxel-sum
8421    Voxel Sum: 200923123.
8422    """
8423    voxel_sum: str
8424    """-voxel-sum: Print sum of all voxel intensities
8425    
8426    Syntax: `-voxel-sum `
8427    
8428    Print the sum of all voxels in the image.
8429    
8430    $ c3d image.img -voxel-sum
8431    Voxel Sum: 200923123"""
8432    
8433    def run(
8434        self,
8435        execution: Execution,
8436    ) -> list[str]:
8437        """
8438        Build command line arguments. This method is called by the main command.
8439        
8440        Args:
8441            execution: The execution object.
8442        Returns:
8443            Command line arguments
8444        """
8445        cargs = []
8446        cargs.extend([
8447            "-voxel-sum",
8448            self.voxel_sum
8449        ])
8450        return cargs
8451
8452
8453@dataclasses.dataclass
8454class C3dVoxelIntegral:
8455    """
8456    -voxel-integral: Print volume integral of all voxel intensities
8457    
8458    Syntax: `-voxel-integral`
8459    
8460    Like **-voxel-sum**, but multiplies the sum of voxel intensities by voxel
8461    volume. This is useful for computing volumes of objects represented by
8462    binary images. The result is in 'ml'.
8463    
8464    $ c3d image.img -voxel-integral
8465    Voxel Integral: 2341.
8466    """
8467    voxel_integral: str
8468    """-voxel-integral: Print volume integral of all voxel intensities
8469    
8470    Syntax: `-voxel-integral`
8471    
8472    Like **-voxel-sum**, but multiplies the sum of voxel intensities by voxel
8473    volume. This is useful for computing volumes of objects represented by
8474    binary images. The result is in 'ml'.
8475    
8476    $ c3d image.img -voxel-integral
8477    Voxel Integral: 2341"""
8478    
8479    def run(
8480        self,
8481        execution: Execution,
8482    ) -> list[str]:
8483        """
8484        Build command line arguments. This method is called by the main command.
8485        
8486        Args:
8487            execution: The execution object.
8488        Returns:
8489            Command line arguments
8490        """
8491        cargs = []
8492        cargs.extend([
8493            "-voxel-integral",
8494            self.voxel_integral
8495        ])
8496        return cargs
8497
8498
8499@dataclasses.dataclass
8500class C3dVoxelwiseRegression:
8501    """
8502    -voxreg, -voxelwise-regression: Regression between two images
8503    
8504    Syntax: `-voxreg regression_order `
8505    
8506    Perform regression between corresponding voxels in two images. This command
8507    takes two images as input, X and Y. This command finds parameters b\_0,
8508    b\_1, ..., b\_k, such that Y is best approximated by b\_0 + b\_1 * X + b\_2
8509    * X^2 + ... + b_k * X^k. Here is an example of linear regression.
8510    
8511    $ c3d Y.nii X.nii -voxreg 2
8512    REGCOEFF[0] = 5.56935
8513    REGCOEFF[1] = 0.844024
8514    
8515    $ c3d Y.nii X.nii -scale 0.844024 -shift 5.56935 -voxreg 2
8516    REGCOEFF[0] = 0
8517    REGCOEFF[1] = 1.
8518    """
8519    voxelwise_regression: str
8520    """-voxreg, -voxelwise-regression: Regression between two images
8521    
8522    Syntax: `-voxreg regression_order `
8523    
8524    Perform regression between corresponding voxels in two images. This command
8525    takes two images as input, X and Y. This command finds parameters b\_0,
8526    b\_1, ..., b\_k, such that Y is best approximated by b\_0 + b\_1 * X + b\_2
8527    * X^2 + ... + b_k * X^k. Here is an example of linear regression.
8528    
8529    $ c3d Y.nii X.nii -voxreg 2
8530    REGCOEFF[0] = 5.56935
8531    REGCOEFF[1] = 0.844024
8532    
8533    $ c3d Y.nii X.nii -scale 0.844024 -shift 5.56935 -voxreg 2
8534    REGCOEFF[0] = 0
8535    REGCOEFF[1] = 1"""
8536    
8537    def run(
8538        self,
8539        execution: Execution,
8540    ) -> list[str]:
8541        """
8542        Build command line arguments. This method is called by the main command.
8543        
8544        Args:
8545            execution: The execution object.
8546        Returns:
8547            Command line arguments
8548        """
8549        cargs = []
8550        cargs.extend([
8551            "-voxelwise-regression",
8552            self.voxelwise_regression
8553        ])
8554        return cargs
8555
8556
8557@dataclasses.dataclass
8558class C3dWarp:
8559    """
8560    No description found.
8561    """
8562    warp: str
8563    """No description found."""
8564    
8565    def run(
8566        self,
8567        execution: Execution,
8568    ) -> list[str]:
8569        """
8570        Build command line arguments. This method is called by the main command.
8571        
8572        Args:
8573            execution: The execution object.
8574        Returns:
8575            Command line arguments
8576        """
8577        cargs = []
8578        cargs.extend([
8579            "-warp",
8580            self.warp
8581        ])
8582        return cargs
8583
8584
8585@dataclasses.dataclass
8586class C3dWarpLabel:
8587    """
8588    No description found.
8589    """
8590    warp_label: str
8591    """No description found."""
8592    
8593    def run(
8594        self,
8595        execution: Execution,
8596    ) -> list[str]:
8597        """
8598        Build command line arguments. This method is called by the main command.
8599        
8600        Args:
8601            execution: The execution object.
8602        Returns:
8603            Command line arguments
8604        """
8605        cargs = []
8606        cargs.extend([
8607            "-warp-label",
8608            self.warp_label
8609        ])
8610        return cargs
8611
8612
8613@dataclasses.dataclass
8614class C3dWrap:
8615    """
8616    -wrap: Wrap (rotate) image
8617    
8618    Syntax: `-wrap <vector> `
8619    
8620    Wrap image around one or more voxel dimensions. Wrapping is typically used
8621    to correct for MRI wrap-around artifacts. The vector must have integer
8622    components, possibly negative. For example,
8623    
8624    c3d badmri.nii.gz -wrap 0x20x0 -o fixedmri.nii.gz
8625    
8626    will wrap the image in the second voxel dimension by 20 voxels (i.e., voxel
8627    at 10x40x20 will me moved to the position 10x20x20).
8628    
8629    
8630    ### Commands: Options and Parameters
8631    
8632    Options change the behavior of commands that *appear later on the command
8633    line*. This is very important. Specifying options after the command will
8634    have no effect.
8635    """
8636    wrap: str
8637    """-wrap: Wrap (rotate) image
8638    
8639    Syntax: `-wrap <vector> `
8640    
8641    Wrap image around one or more voxel dimensions. Wrapping is typically used
8642    to correct for MRI wrap-around artifacts. The vector must have integer
8643    components, possibly negative. For example,
8644    
8645    c3d badmri.nii.gz -wrap 0x20x0 -o fixedmri.nii.gz
8646    
8647    will wrap the image in the second voxel dimension by 20 voxels (i.e., voxel
8648    at 10x40x20 will me moved to the position 10x20x20).
8649    
8650    
8651    ### Commands: Options and Parameters
8652    
8653    Options change the behavior of commands that *appear later on the command
8654    line*. This is very important. Specifying options after the command will
8655    have no effect."""
8656    
8657    def run(
8658        self,
8659        execution: Execution,
8660    ) -> list[str]:
8661        """
8662        Build command line arguments. This method is called by the main command.
8663        
8664        Args:
8665            execution: The execution object.
8666        Returns:
8667            Command line arguments
8668        """
8669        cargs = []
8670        cargs.extend([
8671            "-wrap",
8672            self.wrap
8673        ])
8674        return cargs
8675
8676
8677@dataclasses.dataclass
8678class C3dWeightedSum:
8679    """
8680    -wsum, -weighted-sum: Weighed sum of images with constant weights
8681    
8682    Syntax: `-wsum weight1 weight2 ... weightN `
8683    
8684    Computes weighted sum of the last N images on the stack.
8685    
8686    c3d image1.nii image2.nii image3.nii -wsum 0.2 0.7 0.1 -o wsum.nii
8687    
8688    This command is particularly useful for combining components in a
8689    multicomponent image. For example, for an RGB image, we can convert it to
8690    grayscale (using [ImageMagick][13] formula) as follows:
8691    
8692    c3d -mcs rgb.nii -wsum 0.29900 0.58700 0.11400 -o gray.nii.
8693    """
8694    weighted_sum: str
8695    """-wsum, -weighted-sum: Weighed sum of images with constant weights
8696    
8697    Syntax: `-wsum weight1 weight2 ... weightN `
8698    
8699    Computes weighted sum of the last N images on the stack.
8700    
8701    c3d image1.nii image2.nii image3.nii -wsum 0.2 0.7 0.1 -o wsum.nii
8702    
8703    This command is particularly useful for combining components in a
8704    multicomponent image. For example, for an RGB image, we can convert it to
8705    grayscale (using [ImageMagick][13] formula) as follows:
8706    
8707    c3d -mcs rgb.nii -wsum 0.29900 0.58700 0.11400 -o gray.nii"""
8708    
8709    def run(
8710        self,
8711        execution: Execution,
8712    ) -> list[str]:
8713        """
8714        Build command line arguments. This method is called by the main command.
8715        
8716        Args:
8717            execution: The execution object.
8718        Returns:
8719            Command line arguments
8720        """
8721        cargs = []
8722        cargs.extend([
8723            "-weighted-sum",
8724            self.weighted_sum
8725        ])
8726        return cargs
8727
8728
8729@dataclasses.dataclass
8730class C3dWeightedSumVoxelwise:
8731    """
8732    -wsv, -weighed-sum-voxelwise: Weighed sum of images with spatially varying
8733    weights
8734    
8735    Syntax: `-wsv `
8736    
8737    Computes weighted sum of N weight images and N scalar images. The images
8738    must be interleaved on the stack. All images on the stack are used.
8739    
8740    c3d weight1.nii image1.nii weight2.nii image2.nii weight3.nii image3.nii
8741    -wsv -o mysum.nii.gz
8742    
8743    The **-reorder** command can simplify loading the images:
8744    
8745    c3d weight*.nii image*.nii -reorder 0.5 -wsv -o mysum.nii.gz
8746    
8747    ### Commands: Image Header Manipulation.
8748    """
8749    weighted_sum_voxelwise: str
8750    """-wsv, -weighed-sum-voxelwise: Weighed sum of images with spatially
8751    varying weights
8752    
8753    Syntax: `-wsv `
8754    
8755    Computes weighted sum of N weight images and N scalar images. The images
8756    must be interleaved on the stack. All images on the stack are used.
8757    
8758    c3d weight1.nii image1.nii weight2.nii image2.nii weight3.nii image3.nii
8759    -wsv -o mysum.nii.gz
8760    
8761    The **-reorder** command can simplify loading the images:
8762    
8763    c3d weight*.nii image*.nii -reorder 0.5 -wsv -o mysum.nii.gz
8764    
8765    ### Commands: Image Header Manipulation"""
8766    
8767    def run(
8768        self,
8769        execution: Execution,
8770    ) -> list[str]:
8771        """
8772        Build command line arguments. This method is called by the main command.
8773        
8774        Args:
8775            execution: The execution object.
8776        Returns:
8777            Command line arguments
8778        """
8779        cargs = []
8780        cargs.extend([
8781            "-weighted-sum-voxelwise",
8782            self.weighted_sum_voxelwise
8783        ])
8784        return cargs
8785
8786
8787class C3dOutputs(typing.NamedTuple):
8788    """
8789    Output object returned when calling `c3d_(...)`.
8790    """
8791    root: OutputPathType
8792    """Output root folder. This is the root folder for all outputs."""
8793    operations: typing.List[typing.Union[C3dOutputOutputs]]
8794    """Outputs from `C3dOutput`.This is a list of outputs with the same length
8795    and order as the inputs."""
8796
8797
8798def c3d_(
8799    input_: list[InputPathType],
8800    operations: list[typing.Union[C3dAccum, C3dAcos, C3dAdd, C3dAlignLandmarks, C3dAnisotropicDiffusion, C3dAntialias, C3dSet, C3dAsin, C3dAtan2, C3dBackground, C3dN4BiasCorrection, C3dBinarize, C3dCanny, C3dCeil, C3dCentroid, C3dCentroidMark, C3dConnectedComponents, C3dClear, C3dClip, C3dColorMap, C3dCompress, C3dNoCompress, C3dConv, C3dCoordinateMapVoxel, C3dCoordinateMapPhysical, C3dCopyTransform, C3dCos, C3dCreate, C3dDicomSeriesList, C3dDicomSeriesRead, C3dDilate, C3dDivide, C3dDuplicate, C3dEndaccum, C3dEndfor, C3dErode, C3dErf, C3dExp, C3dExportPatches, C3dExportPatchesAug, C3dExtrudeSeg, C3dFillBackgroundWithNoise, C3dFft, C3dFlip, C3dFloor, C3dForeach, C3dForeachComp, C3dGlm, C3dGradient, C3dHelp, C3dHolefill, C3dHessianEigenvalues, C3dHessianObjectness, C3dHistogramMatch, C3dInfo, C3dInfoFull, C3dInsert, C3dInterpolation, C3dIterations, C3dLabelOverlap, C3dLabelStatistics, C3dLandmarksToSpheres, C3dLaplacian, C3dLevelset, C3dLevelsetCurvature, C3dLevelsetAdvection, C3dLog, C3dLog10, C3dManual, C3dMatchBoundingBox, C3dMaximum, C3dMulticomponentSplit, C3dMean, C3dMedianFilter, C3dMerge, C3dMeanFilter, C3dMutualInfo, C3dMinimum, C3dMixtureModel, C3dMoments, C3dMattesMutualInfo, C3dMeanSquare, C3dMultiply, C3dNormalizedCrossCorrelation, C3dNormalizedCorrelation, C3dNormalizedMutualInfo, C3dNoiseGaussian, C3dNoisePoisson, C3dNoiseSpeckle, C3dNoiseSaltPepper, C3dNoMulticomponentSplit, C3dNormalizeLocalWindow, C3dNormpdf, C3dNoround, C3dNospm, C3dOutput, C3dOutputMulticomponent, C3dOutputMultipleMulticomponent, C3dOrient, C3dOutputMultiple, C3dOrient_, C3dOrigin, C3dOriginVoxel, C3dOriginVoxelCoord, C3dOverlap, C3dOverlayLabelImage, C3dPad, C3dPadTo, C3dPca, C3dPercentIntensityMode, C3dPixel, C3dPop, C3dPopas, C3dProbe, C3dPush, C3dRank, C3dReciprocal, C3dRegion, C3dReorder, C3dRetainLabels, C3dRfApply, C3dRfTrain, C3dRfParamPatch, C3dRfParamUsexyz, C3dRfParamNousexyz, C3dRfParamNtrees, C3dRfParamTreedepth, C3dSetSform, C3dReplace, C3dResample, C3dResampleIso, C3dResampleMm, C3dResliceItk, C3dResliceMatrix, C3dResliceIdentity, C3dRgb2hsv, C3dRms, C3dRound, C3dScale, C3dSetSform_, C3dSin, C3dSlice, C3dSliceAll, C3dSharpen, C3dShift, C3dSignedDistanceTransform, C3dSmooth, C3dSmoothFast, C3dSpacing, C3dSplit, C3dSqrt, C3dStaple, C3dStructureTensorEigenvalues, C3dSpm, C3dSubtract, C3dSupervoxel, C3dStretch, C3dSwapdim, C3dTestImage, C3dTestProbe, C3dThreshold, C3dTile, C3dTrim, C3dTrimToSize, C3dType, C3dVerbose, C3dNoverbose, C3dVersion, C3dVote, C3dVoteMrf, C3dVoteLabel, C3dVoxelSum, C3dVoxelIntegral, C3dVoxelwiseRegression, C3dWarp, C3dWarpLabel, C3dWrap, C3dWeightedSum, C3dWeightedSumVoxelwise]],
8801    output: str,
8802    runner: Runner | None = None,
8803) -> C3dOutputs:
8804    """
8805    C3D is a command-line tool for medical image processing.
8806    
8807    Author: ITK-Snap Team
8808    
8809    Args:
8810        input_: The input image to process.
8811        operations: The operations to perform.
8812        output: The output image.
8813        runner: Command runner.
8814    Returns:
8815        NamedTuple of outputs (described in `C3dOutputs`).
8816    """
8817    runner = runner or get_global_runner()
8818    execution = runner.start_execution(C3D_METADATA)
8819    cargs = []
8820    cargs.append("c3d")
8821    cargs.append(" ".join([execution.input_file(f) for f in input_]))
8822    cargs.extend([a for c in [s.run(execution) for s in operations] for a in c])
8823    cargs.extend([
8824        "-o",
8825        output
8826    ])
8827    ret = C3dOutputs(
8828        root=execution.output_file("."),
8829        operations=[i.outputs(execution) if hasattr(i, "outputs") else None for i in operations],
8830    )
8831    execution.run(cargs)
8832    return ret
8833
8834
8835__all__ = [
8836    "C3D_METADATA",
8837    "C3dAccum",
8838    "C3dAcos",
8839    "C3dAdd",
8840    "C3dAlignLandmarks",
8841    "C3dAnisotropicDiffusion",
8842    "C3dAntialias",
8843    "C3dAsin",
8844    "C3dAtan2",
8845    "C3dBackground",
8846    "C3dBinarize",
8847    "C3dCanny",
8848    "C3dCeil",
8849    "C3dCentroid",
8850    "C3dCentroidMark",
8851    "C3dClear",
8852    "C3dClip",
8853    "C3dColorMap",
8854    "C3dCompress",
8855    "C3dConnectedComponents",
8856    "C3dConv",
8857    "C3dCoordinateMapPhysical",
8858    "C3dCoordinateMapVoxel",
8859    "C3dCopyTransform",
8860    "C3dCos",
8861    "C3dCreate",
8862    "C3dDicomSeriesList",
8863    "C3dDicomSeriesRead",
8864    "C3dDilate",
8865    "C3dDivide",
8866    "C3dDuplicate",
8867    "C3dEndaccum",
8868    "C3dEndfor",
8869    "C3dErf",
8870    "C3dErode",
8871    "C3dExp",
8872    "C3dExportPatches",
8873    "C3dExportPatchesAug",
8874    "C3dExtrudeSeg",
8875    "C3dFft",
8876    "C3dFillBackgroundWithNoise",
8877    "C3dFlip",
8878    "C3dFloor",
8879    "C3dForeach",
8880    "C3dForeachComp",
8881    "C3dGlm",
8882    "C3dGradient",
8883    "C3dHelp",
8884    "C3dHessianEigenvalues",
8885    "C3dHessianObjectness",
8886    "C3dHistogramMatch",
8887    "C3dHolefill",
8888    "C3dInfo",
8889    "C3dInfoFull",
8890    "C3dInsert",
8891    "C3dInterpolation",
8892    "C3dIterations",
8893    "C3dLabelOverlap",
8894    "C3dLabelStatistics",
8895    "C3dLandmarksToSpheres",
8896    "C3dLaplacian",
8897    "C3dLevelset",
8898    "C3dLevelsetAdvection",
8899    "C3dLevelsetCurvature",
8900    "C3dLog",
8901    "C3dLog10",
8902    "C3dManual",
8903    "C3dMatchBoundingBox",
8904    "C3dMattesMutualInfo",
8905    "C3dMaximum",
8906    "C3dMean",
8907    "C3dMeanFilter",
8908    "C3dMeanSquare",
8909    "C3dMedianFilter",
8910    "C3dMerge",
8911    "C3dMinimum",
8912    "C3dMixtureModel",
8913    "C3dMoments",
8914    "C3dMulticomponentSplit",
8915    "C3dMultiply",
8916    "C3dMutualInfo",
8917    "C3dN4BiasCorrection",
8918    "C3dNoCompress",
8919    "C3dNoMulticomponentSplit",
8920    "C3dNoiseGaussian",
8921    "C3dNoisePoisson",
8922    "C3dNoiseSaltPepper",
8923    "C3dNoiseSpeckle",
8924    "C3dNormalizeLocalWindow",
8925    "C3dNormalizedCorrelation",
8926    "C3dNormalizedCrossCorrelation",
8927    "C3dNormalizedMutualInfo",
8928    "C3dNormpdf",
8929    "C3dNoround",
8930    "C3dNospm",
8931    "C3dNoverbose",
8932    "C3dOrient",
8933    "C3dOrient_",
8934    "C3dOrigin",
8935    "C3dOriginVoxel",
8936    "C3dOriginVoxelCoord",
8937    "C3dOutput",
8938    "C3dOutputMulticomponent",
8939    "C3dOutputMultiple",
8940    "C3dOutputMultipleMulticomponent",
8941    "C3dOutputOutputs",
8942    "C3dOutputs",
8943    "C3dOverlap",
8944    "C3dOverlayLabelImage",
8945    "C3dPad",
8946    "C3dPadTo",
8947    "C3dPca",
8948    "C3dPercentIntensityMode",
8949    "C3dPixel",
8950    "C3dPop",
8951    "C3dPopas",
8952    "C3dProbe",
8953    "C3dPush",
8954    "C3dRank",
8955    "C3dReciprocal",
8956    "C3dRegion",
8957    "C3dReorder",
8958    "C3dReplace",
8959    "C3dResample",
8960    "C3dResampleIso",
8961    "C3dResampleMm",
8962    "C3dResliceIdentity",
8963    "C3dResliceItk",
8964    "C3dResliceMatrix",
8965    "C3dRetainLabels",
8966    "C3dRfApply",
8967    "C3dRfParamNousexyz",
8968    "C3dRfParamNtrees",
8969    "C3dRfParamPatch",
8970    "C3dRfParamTreedepth",
8971    "C3dRfParamUsexyz",
8972    "C3dRfTrain",
8973    "C3dRgb2hsv",
8974    "C3dRms",
8975    "C3dRound",
8976    "C3dScale",
8977    "C3dSet",
8978    "C3dSetSform",
8979    "C3dSetSform_",
8980    "C3dSharpen",
8981    "C3dShift",
8982    "C3dSignedDistanceTransform",
8983    "C3dSin",
8984    "C3dSlice",
8985    "C3dSliceAll",
8986    "C3dSmooth",
8987    "C3dSmoothFast",
8988    "C3dSpacing",
8989    "C3dSplit",
8990    "C3dSpm",
8991    "C3dSqrt",
8992    "C3dStaple",
8993    "C3dStretch",
8994    "C3dStructureTensorEigenvalues",
8995    "C3dSubtract",
8996    "C3dSupervoxel",
8997    "C3dSwapdim",
8998    "C3dTestImage",
8999    "C3dTestProbe",
9000    "C3dThreshold",
9001    "C3dTile",
9002    "C3dTrim",
9003    "C3dTrimToSize",
9004    "C3dType",
9005    "C3dVerbose",
9006    "C3dVersion",
9007    "C3dVote",
9008    "C3dVoteLabel",
9009    "C3dVoteMrf",
9010    "C3dVoxelIntegral",
9011    "C3dVoxelSum",
9012    "C3dVoxelwiseRegression",
9013    "C3dWarp",
9014    "C3dWarpLabel",
9015    "C3dWeightedSum",
9016    "C3dWeightedSumVoxelwise",
9017    "C3dWrap",
9018    "c3d_",
9019]